mirrors/signal-desktop
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 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/*
dist/*
libtextsecure/libsignal-protocol.js
test/fixtures.js
test/blanket_mocha.js
/**/*.json
/**/*.css

53
libtextsecure/ProvisioningCipher.js
View file

@ -8,7 +8,7 @@ ProvisioningCipher.prototype = {
var masterEphemeral = provisionEnvelope.publicKey.toArrayBuffer();
var message = provisionEnvelope.body.toArrayBuffer();
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);
@ -16,27 +16,37 @@ ProvisioningCipher.prototype = {
var ivAndCiphertext = message.slice(0, message.byteLength - 32);
var ciphertext = message.slice(16 + 1, message.byteLength - 32);
return libsignal.Curve.async.calculateAgreement(
masterEphemeral, this.keyPair.privKey
).then(function(ecRes) {
return libsignal.Curve.async
.calculateAgreement(masterEphemeral, this.keyPair.privKey)
.then(function(ecRes) {
return libsignal.HKDF.deriveSecrets(
ecRes, new ArrayBuffer(32), "TextSecure Provisioning Message"
ecRes,
new ArrayBuffer(32),
'TextSecure Provisioning Message'
);
}).then(function(keys) {
return libsignal.crypto.verifyMAC(ivAndCiphertext, keys[1], mac, 32).then(function() {
})
.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 provisionMessage = textsecure.protobuf.ProvisionMessage.decode(
plaintext
);
var privKey = provisionMessage.identityKeyPrivate.toArrayBuffer();
return libsignal.Curve.async.createKeyPair(privKey).then(function(keyPair) {
return libsignal.Curve.async
.createKeyPair(privKey)
.then(function(keyPair) {
var ret = {
identityKeyPair: keyPair,
number: provisionMessage.number,
provisioningCode: provisionMessage.provisioningCode,
userAgent: provisionMessage.userAgent,
readReceipts : provisionMessage.readReceipts
readReceipts: provisionMessage.readReceipts,
};
if (provisionMessage.profileKey) {
ret.profileKey = provisionMessage.profileKey.toArrayBuffer();
@ -46,16 +56,24 @@ ProvisioningCipher.prototype = {
});
},
getPublicKey: function() {
return Promise.resolve().then(function() {
return Promise.resolve()
.then(
function() {
if (!this.keyPair) {
return libsignal.Curve.async.generateKeyPair().then(function(keyPair) {
return libsignal.Curve.async.generateKeyPair().then(
function(keyPair) {
this.keyPair = keyPair;
}.bind(this));
}.bind(this)
);
}
}.bind(this)).then(function() {
}.bind(this)
)
.then(
function() {
return this.keyPair.pubKey;
}.bind(this));
}
}.bind(this)
);
},
};
libsignal.ProvisioningCipher = function() {
@ -64,5 +82,4 @@ libsignal.ProvisioningCipher = function() {
this.decrypt = cipher.decrypt.bind(cipher);
this.getPublicKey = cipher.getPublicKey.bind(cipher);
};
})();

217
libtextsecure/message_receiver.js
View file

@ -122,9 +122,10 @@ MessageReceiver.prototype.extend({
this.onEmpty();
}
// 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
.catch((e) => {
.catch(e => {
const event = new Event('error');
event.error = e;
return this.dispatchAndWait(event);
@ -146,10 +147,9 @@ MessageReceiver.prototype.extend({
return;
}
const promise = textsecure.crypto.decryptWebsocketMessage(
request.body,
this.signalingKey
).then((plaintext) => {
const promise = textsecure.crypto
.decryptWebsocketMessage(request.body, this.signalingKey)
.then(plaintext => {
const envelope = textsecure.protobuf.Envelope.decode(plaintext);
// After this point, decoding errors are not the server's
// fault, and we should handle them gracefully and tell the
@ -159,18 +159,25 @@ MessageReceiver.prototype.extend({
return request.respond(200, 'OK');
}
return this.addToCache(envelope, plaintext).then(() => {
return this.addToCache(envelope, plaintext).then(
() => {
request.respond(200, 'OK');
this.queueEnvelope(envelope);
}, (error) => {
},
error => {
console.log(
'handleRequest error trying to add message to cache:',
error && error.stack ? error.stack : error
);
});
}).catch((e) => {
}
);
})
.catch(e => {
request.respond(500, 'Bad encrypted websocket message');
console.log('Error handling incoming message:', e && e.stack ? e.stack : e);
console.log(
'Error handling incoming message:',
e && e.stack ? e.stack : e
);
const ev = new Event('error');
ev.error = e;
return this.dispatchAndWait(ev);
@ -203,7 +210,7 @@ MessageReceiver.prototype.extend({
this.incoming = [];
const dispatchEmpty = () => {
console.log('MessageReceiver: emitting \'empty\' event');
console.log("MessageReceiver: emitting 'empty' event");
const ev = new Event('empty');
return this.dispatchAndWait(ev);
};
@ -224,7 +231,8 @@ MessageReceiver.prototype.extend({
const { incoming } = this;
this.incoming = [];
const queueDispatch = () => this.addToQueue(() => {
const queueDispatch = () =>
this.addToQueue(() => {
console.log('drained');
});
@ -241,7 +249,7 @@ MessageReceiver.prototype.extend({
this.dispatchEvent(ev);
},
queueAllCached() {
return this.getAllFromCache().then((items) => {
return this.getAllFromCache().then(items => {
for (let i = 0, max = items.length; i < max; i += 1) {
this.queueCached(items[i]);
}
@ -273,7 +281,9 @@ MessageReceiver.prototype.extend({
}
},
getEnvelopeId(envelope) {
return `${envelope.source}.${envelope.sourceDevice} ${envelope.timestamp.toNumber()}`;
return `${envelope.source}.${
envelope.sourceDevice
} ${envelope.timestamp.toNumber()}`;
},
stringToArrayBuffer(string) {
// eslint-disable-next-line new-cap
@ -281,23 +291,28 @@ MessageReceiver.prototype.extend({
},
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');
return Promise.all(_.map(items, (item) => {
return Promise.all(
_.map(items, item => {
const attempts = 1 + (item.attempts || 0);
if (attempts >= 5) {
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) => {
})
).then(
() => items,
error => {
console.log(
'getAllFromCache error updating items after load:',
error && error.stack ? error.stack : error
);
return items;
});
}
);
});
},
addToCache(envelope, plaintext) {
@ -332,7 +347,7 @@ MessageReceiver.prototype.extend({
);
const promise = this.addToQueue(taskWithTimeout);
return promise.catch((error) => {
return promise.catch(error => {
console.log(
'queueDecryptedEnvelope error handling envelope',
id,
@ -346,10 +361,13 @@ MessageReceiver.prototype.extend({
console.log('queueing envelope', id);
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);
return promise.catch((error) => {
return promise.catch(error => {
console.log(
'queueEnvelope error handling envelope',
id,
@ -448,26 +466,36 @@ MessageReceiver.prototype.extend({
switch (envelope.type) {
case textsecure.protobuf.Envelope.Type.CIPHERTEXT:
console.log('message from', this.getEnvelopeId(envelope));
promise = sessionCipher.decryptWhisperMessage(ciphertext).then(this.unpad);
promise = sessionCipher
.decryptWhisperMessage(ciphertext)
.then(this.unpad);
break;
case textsecure.protobuf.Envelope.Type.PREKEY_BUNDLE:
console.log('prekey message from', this.getEnvelopeId(envelope));
promise = this.decryptPreKeyWhisperMessage(ciphertext, sessionCipher, address);
promise = this.decryptPreKeyWhisperMessage(
ciphertext,
sessionCipher,
address
);
break;
default:
promise = Promise.reject(new Error('Unknown message type'));
}
return promise.then(plaintext => this.updateCache(
envelope,
plaintext
).then(() => plaintext, (error) => {
return promise
.then(plaintext =>
this.updateCache(envelope, plaintext).then(
() => plaintext,
error => {
console.log(
'decrypt failed to save decrypted message contents to cache:',
error && error.stack ? error.stack : error
);
return plaintext;
})).catch((error) => {
}
)
)
.catch(error => {
let errorToThrow = error;
if (error.message === 'Unknown identity key') {
@ -508,17 +536,20 @@ MessageReceiver.prototype.extend({
throw e;
}
},
handleSentMessage(envelope, destination, timestamp, msg, expirationStartTimestamp) {
handleSentMessage(
envelope,
destination,
timestamp,
msg,
expirationStartTimestamp
) {
let p = Promise.resolve();
// eslint-disable-next-line no-bitwise
if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) {
p = this.handleEndSession(destination);
}
return p.then(() => this.processDecrypted(
envelope,
msg,
this.number
).then((message) => {
return p.then(() =>
this.processDecrypted(envelope, msg, this.number).then(message => {
const ev = new Event('sent');
ev.confirm = this.removeFromCache.bind(this, envelope);
ev.data = {
@ -531,7 +562,8 @@ MessageReceiver.prototype.extend({
ev.data.expirationStartTimestamp = expirationStartTimestamp.toNumber();
}
return this.dispatchAndWait(ev);
}));
})
);
},
handleDataMessage(envelope, msg) {
console.log('data message from', this.getEnvelopeId(envelope));
@ -540,11 +572,8 @@ MessageReceiver.prototype.extend({
if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) {
p = this.handleEndSession(envelope.source);
}
return p.then(() => this.processDecrypted(
envelope,
msg,
envelope.source
).then((message) => {
return p.then(() =>
this.processDecrypted(envelope, msg, envelope.source).then(message => {
const ev = new Event('message');
ev.confirm = this.removeFromCache.bind(this, envelope);
ev.data = {
@ -555,23 +584,22 @@ MessageReceiver.prototype.extend({
message,
};
return this.dispatchAndWait(ev);
}));
})
);
},
handleLegacyMessage(envelope) {
return this.decrypt(
envelope,
envelope.legacyMessage
).then(plaintext => this.innerHandleLegacyMessage(envelope, plaintext));
return this.decrypt(envelope, envelope.legacyMessage).then(plaintext =>
this.innerHandleLegacyMessage(envelope, plaintext)
);
},
innerHandleLegacyMessage(envelope, plaintext) {
const message = textsecure.protobuf.DataMessage.decode(plaintext);
return this.handleDataMessage(envelope, message);
},
handleContentMessage(envelope) {
return this.decrypt(
envelope,
envelope.content
).then(plaintext => this.innerHandleContentMessage(envelope, plaintext));
return this.decrypt(envelope, envelope.content).then(plaintext =>
this.innerHandleContentMessage(envelope, plaintext)
);
},
innerHandleContentMessage(envelope, plaintext) {
const content = textsecure.protobuf.Content.decode(plaintext);
@ -595,7 +623,9 @@ MessageReceiver.prototype.extend({
},
handleReceiptMessage(envelope, receiptMessage) {
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) {
const ev = new Event('delivery');
ev.confirm = this.removeFromCache.bind(this, envelope);
@ -606,7 +636,9 @@ MessageReceiver.prototype.extend({
};
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) {
const ev = new Event('read');
ev.confirm = this.removeFromCache.bind(this, envelope);
@ -734,12 +766,13 @@ MessageReceiver.prototype.extend({
let groupDetails = groupBuffer.next();
const promises = [];
while (groupDetails !== undefined) {
const getGroupDetails = (details) => {
const getGroupDetails = details => {
// eslint-disable-next-line no-param-reassign
details.id = details.id.toBinary();
if (details.active) {
return textsecure.storage.groups.getGroup(details.id)
.then((existingGroup) => {
return textsecure.storage.groups
.getGroup(details.id)
.then(existingGroup => {
if (existingGroup === undefined) {
return textsecure.storage.groups.createNewGroup(
details.members,
@ -750,17 +783,20 @@ MessageReceiver.prototype.extend({
details.id,
details.members
);
}).then(() => details);
})
.then(() => details);
}
return Promise.resolve(details);
};
const promise = getGroupDetails(groupDetails).then((details) => {
const promise = getGroupDetails(groupDetails)
.then(details => {
const ev = new Event('group');
ev.confirm = this.removeFromCache.bind(this, envelope);
ev.groupDetails = details;
return this.dispatchAndWait(ev);
}).catch((e) => {
})
.catch(e => {
console.log('error processing group', e);
});
groupDetails = groupBuffer.next();
@ -803,7 +839,8 @@ MessageReceiver.prototype.extend({
attachment.data = data;
}
return this.server.getAttachment(attachment.id)
return this.server
.getAttachment(attachment.id)
.then(decryptAttachment)
.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
const data = content.dataMessage;
if (data && !data.attachments.length && !data.body && !data.expireTimer &&
!data.flags && !data.group) {
if (
data &&
!data.attachments.length &&
!data.body &&
!data.expireTimer &&
!data.flags &&
!data.group
) {
return false;
}
@ -857,7 +900,7 @@ MessageReceiver.prototype.extend({
ciphertext,
sessionCipher,
address
).then((plaintext) => {
).then(plaintext => {
const envelope = {
source: number,
sourceDevice: device,
@ -901,7 +944,8 @@ MessageReceiver.prototype.extend({
console.log('got end session');
const deviceIds = await textsecure.storage.protocol.getDeviceIds(number);
return Promise.all(deviceIds.map((deviceId) => {
return Promise.all(
deviceIds.map(deviceId => {
const address = new libsignal.SignalProtocolAddress(number, deviceId);
const sessionCipher = new libsignal.SessionCipher(
textsecure.storage.protocol,
@ -910,7 +954,8 @@ MessageReceiver.prototype.extend({
console.log('deleting sessions for', address.toString());
return sessionCipher.deleteAllSessionsForDevice();
}));
})
);
},
processDecrypted(envelope, decrypted, source) {
/* eslint-disable no-bitwise, no-param-reassign */
@ -928,7 +973,6 @@ MessageReceiver.prototype.extend({
decrypted.expireTimer = 0;
}
if (decrypted.flags & FLAGS.END_SESSION) {
decrypted.body = null;
decrypted.attachments = [];
@ -949,7 +993,9 @@ MessageReceiver.prototype.extend({
if (decrypted.group !== null) {
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) {
promises.push(this.handleAttachment(decrypted.group.avatar));
}
@ -957,9 +1003,13 @@ MessageReceiver.prototype.extend({
const storageGroups = textsecure.storage.groups;
promises.push(storageGroups.getNumbers(decrypted.group.id).then((existingGroup) => {
promises.push(
storageGroups.getNumbers(decrypted.group.id).then(existingGroup => {
if (existingGroup === undefined) {
if (decrypted.group.type !== textsecure.protobuf.GroupContext.Type.UPDATE) {
if (
decrypted.group.type !==
textsecure.protobuf.GroupContext.Type.UPDATE
) {
decrypted.group.members = [source];
console.log('Got message for unknown group');
}
@ -972,7 +1022,9 @@ MessageReceiver.prototype.extend({
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');
console.log(
'Sender was not a member of the group they were sending from'
);
}
switch (decrypted.group.type) {
@ -987,9 +1039,14 @@ MessageReceiver.prototype.extend({
decrypted.body = null;
decrypted.attachments = [];
if (source === this.number) {
return textsecure.storage.groups.deleteGroup(decrypted.group.id);
return textsecure.storage.groups.deleteGroup(
decrypted.group.id
);
}
return textsecure.storage.groups.removeNumber(decrypted.group.id, source);
return textsecure.storage.groups.removeNumber(
decrypted.group.id,
source
);
case textsecure.protobuf.GroupContext.Type.DELIVER:
decrypted.group.name = null;
decrypted.group.members = [];
@ -999,7 +1056,8 @@ MessageReceiver.prototype.extend({
this.removeFromCache(envelope);
throw new Error('Unknown group message type');
}
}));
})
);
}
for (let i = 0, max = decrypted.attachments.length; i < max; i += 1) {
@ -1021,12 +1079,14 @@ MessageReceiver.prototype.extend({
if (thumbnail) {
// We don't want the failure of a thumbnail download to fail the handling of
// this message entirely, like we do for full attachments.
promises.push(this.handleAttachment(thumbnail).catch((error) => {
promises.push(
this.handleAttachment(thumbnail).catch(error => {
console.log(
'Problem loading thumbnail for quote',
error && error.stack ? error.stack : error
);
}));
})
);
}
}
}
@ -1052,8 +1112,12 @@ textsecure.MessageReceiver = function MessageReceiverWrapper(
signalingKey,
options
);
this.addEventListener = messageReceiver.addEventListener.bind(messageReceiver);
this.removeEventListener = messageReceiver.removeEventListener.bind(messageReceiver);
this.addEventListener = messageReceiver.addEventListener.bind(
messageReceiver
);
this.removeEventListener = messageReceiver.removeEventListener.bind(
messageReceiver
);
this.getStatus = messageReceiver.getStatus.bind(messageReceiver);
this.close = messageReceiver.close.bind(messageReceiver);
messageReceiver.connect();
@ -1067,4 +1131,3 @@ textsecure.MessageReceiver = function MessageReceiverWrapper(
textsecure.MessageReceiver.prototype = {
constructor: textsecure.MessageReceiver,
};

229
libtextsecure/outgoing_message.js
View file

@ -1,4 +1,11 @@
function OutgoingMessage(server, timestamp, numbers, message, silent, callback) {
function OutgoingMessage(
server,
timestamp,
numbers,
message,
silent,
callback
) {
if (message instanceof textsecure.protobuf.DataMessage) {
var content = new textsecure.protobuf.Content();
content.dataMessage = message;
@ -21,12 +28,20 @@ OutgoingMessage.prototype = {
numberCompleted: function() {
this.numbersCompleted++;
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);
if (!error || (error.name === 'HTTPError' && error.code !== 404)) {
error = new textsecure.OutgoingMessageError(
number,
this.message.toArrayBuffer(),
this.timestamp,
error
);
}
error.number = number;
@ -36,44 +51,71 @@ OutgoingMessage.prototype = {
},
reloadDevicesAndSend: function(number, recurse) {
return function() {
return textsecure.storage.protocol.getDeviceIds(number).then(function(deviceIds) {
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.registerError(
number,
'Got empty device list when loading device keys',
null
);
}
return this.doSendMessage(number, deviceIds, recurse);
}.bind(this));
}.bind(this)
);
}.bind(this);
},
getKeysForNumber: function(number, updateDevices) {
var handleResult = function(response) {
return Promise.all(response.devices.map(function(device) {
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 (
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!");
console.log('device registrationId 0!');
}
return builder.processPreKey(device).catch(function(error) {
if (error.message === "Identity key changed") {
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)));
}.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) {
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]);
@ -83,16 +125,21 @@ OutgoingMessage.prototype = {
} else {
throw e;
}
}.bind(this));
}.bind(this));
}.bind(this));
}.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) {
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
@ -100,7 +147,12 @@ OutgoingMessage.prototype = {
if (e.code === 404) {
throw new textsecure.UnregisteredUserError(number, e);
}
throw new textsecure.SendMessageNetworkError(number, jsonData, e, timestamp);
throw new textsecure.SendMessageNetworkError(
number,
jsonData,
e,
timestamp
);
}
throw e;
});
@ -133,7 +185,9 @@ OutgoingMessage.prototype = {
var ciphers = {};
var plaintext = this.getPlaintext();
return Promise.all(deviceIds.map(function(deviceId) {
return Promise.all(
deviceIds.map(
function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var ourNumber = textsecure.storage.user.getNumber();
@ -144,66 +198,114 @@ OutgoingMessage.prototype = {
options.messageKeysLimit = false;
}
var sessionCipher = new libsignal.SessionCipher(textsecure.storage.protocol, address, options);
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)
content: btoa(ciphertext.body),
};
});
}.bind(this))).then(function(jsonData) {
return this.transmitMessage(number, jsonData, this.timestamp).then(function() {
}.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)) {
}.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);
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);
p = this.removeDeviceIdsForNumber(
number,
error.response.extraDevices
);
} else {
p = Promise.all(error.response.staleDevices.map(function(deviceId) {
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") {
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)
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);
this.registerError(
number,
'Failed to create or send message',
error
);
}
}.bind(this));
}.bind(this)
);
},
getStaleDeviceIdsForNumber: function(number) {
return textsecure.storage.protocol.getDeviceIds(number).then(function(deviceIds) {
return textsecure.storage.protocol
.getDeviceIds(number)
.then(function(deviceIds) {
if (deviceIds.length === 0) {
return [1];
}
var updateDevices = [];
return Promise.all(deviceIds.map(function(deviceId) {
return Promise.all(
deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var sessionCipher = new libsignal.SessionCipher(textsecure.storage.protocol, address);
var sessionCipher = new libsignal.SessionCipher(
textsecure.storage.protocol,
address
);
return sessionCipher.hasOpenSession().then(function(hasSession) {
if (!hasSession) {
updateDevices.push(deviceId);
}
});
})).then(function() {
})
).then(function() {
return updateDevices;
});
});
@ -213,7 +315,7 @@ OutgoingMessage.prototype = {
var promise = Promise.resolve();
for (var j in deviceIdsToRemove) {
promise = promise.then(function() {
var encodedNumber = number + "." + deviceIdsToRemove[j];
var encodedNumber = number + '.' + deviceIdsToRemove[j];
return textsecure.storage.protocol.removeSession(encodedNumber);
});
}
@ -221,21 +323,30 @@ OutgoingMessage.prototype = {
},
sendToNumber: function(number) {
return this.getStaleDeviceIdsForNumber(number).then(function(updateDevices) {
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") {
.catch(
function(error) {
if (error.message === 'Identity key changed') {
error = new textsecure.OutgoingIdentityKeyError(
number, error.originalMessage, error.timestamp, error.identityKey
number,
error.originalMessage,
error.timestamp,
error.identityKey
);
this.registerError(number, "Identity key changed", error);
this.registerError(number, 'Identity key changed', error);
} else {
this.registerError(
number, "Failed to retrieve new device keys for number " + number, error
number,
'Failed to retrieve new device keys for number ' + number,
error
);
}
}.bind(this));
}.bind(this));
}
}.bind(this)
);
}.bind(this)
);
},
};

27
libtextsecure/protobufs.js
View file

@ -1,27 +1,40 @@
;(function() {
(function() {
'use strict';
window.textsecure = window.textsecure || {};
window.textsecure.protobuf = {};
function loadProtoBufs(filename) {
return dcodeIO.ProtoBuf.loadProtoFile({root: window.PROTO_ROOT, file: filename}, function(error, result) {
return dcodeIO.ProtoBuf.loadProtoFile(
{ root: window.PROTO_ROOT, file: filename },
function(error, result) {
if (error) {
var text = 'Error loading protos from ' + filename + ' (root: ' + window.PROTO_ROOT + ') '
+ (error && error.stack ? error.stack : error);
var text =
'Error loading protos from ' +
filename +
' (root: ' +
window.PROTO_ROOT +
') ' +
(error && error.stack ? error.stack : error);
console.log(text);
throw error;
}
var protos = result.build('signalservice');
if (!protos) {
var text = 'Error loading protos from ' + filename + ' (root: ' + window.PROTO_ROOT + ')';
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('SubProtocol.proto');

2
libtextsecure/protocol_wrapper.js
View file

@ -1,4 +1,4 @@
;(function() {
(function() {
'use strict';
window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {};

434
libtextsecure/sendmessage.js
View file

@ -51,17 +51,25 @@ function Message(options) {
}
}
if (this.isEndSession()) {
if (this.body !== null || this.group !== null || this.attachments.length !== 0) {
if (
this.body !== null ||
this.group !== null ||
this.attachments.length !== 0
) {
throw new Error('Invalid end session message');
}
} else {
if ( (typeof this.timestamp !== 'number') ||
(this.body && typeof this.body !== 'string') ) {
if (
typeof this.timestamp !== 'number' ||
(this.body && typeof this.body !== 'string')
) {
throw new Error('Invalid message body');
}
if (this.group) {
if ( (typeof this.group.id !== 'string') ||
(typeof this.group.type !== 'number') ) {
if (
typeof this.group.id !== 'string' ||
typeof this.group.type !== 'number'
) {
throw new Error('Invalid group context');
}
}
@ -71,7 +79,7 @@ function Message(options) {
Message.prototype = {
constructor: Message,
isEndSession: function() {
return (this.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION);
return this.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION;
},
toProto: function() {
if (this.dataMessage instanceof textsecure.protobuf.DataMessage) {
@ -88,10 +96,11 @@ Message.prototype = {
if (this.group) {
proto.group = new textsecure.protobuf.GroupContext();
proto.group.id = stringToArrayBuffer(this.group.id);
proto.group.type = this.group.type
proto.group.type = this.group.type;
}
if (this.quote) {
var QuotedAttachment = textsecure.protobuf.DataMessage.Quote.QuotedAttachment;
var QuotedAttachment =
textsecure.protobuf.DataMessage.Quote.QuotedAttachment;
var Quote = textsecure.protobuf.DataMessage.Quote;
proto.quote = new Quote();
@ -100,7 +109,9 @@ Message.prototype = {
quote.id = this.quote.id;
quote.author = this.quote.author;
quote.text = this.quote.text;
quote.attachments = (this.quote.attachments || []).map(function(attachment) {
quote.attachments = (this.quote.attachments || []).map(function(
attachment
) {
var quotedAttachment = new QuotedAttachment();
quotedAttachment.contentType = attachment.contentType;
@ -125,7 +136,7 @@ Message.prototype = {
},
toArrayBuffer: function() {
return this.toProto().toArrayBuffer();
}
},
};
function MessageSender(url, username, password, cdn_url) {
@ -142,20 +153,29 @@ MessageSender.prototype = {
return Promise.resolve(undefined);
}
if (!(attachment.data instanceof ArrayBuffer) &&
!ArrayBuffer.isView(attachment.data)) {
return Promise.reject(new TypeError(
if (
!(attachment.data instanceof ArrayBuffer) &&
!ArrayBuffer.isView(attachment.data)
) {
return Promise.reject(
new TypeError(
'`attachment.data` must be an `ArrayBuffer` or `ArrayBufferView`; got: ' +
typeof attachment.data
));
)
);
}
var proto = new textsecure.protobuf.AttachmentPointer();
proto.key = libsignal.crypto.getRandomBytes(64);
var iv = libsignal.crypto.getRandomBytes(16);
return textsecure.crypto.encryptAttachment(attachment.data, proto.key, iv).then(function(result) {
return this.server.putAttachment(result.ciphertext).then(function(id) {
return textsecure.crypto
.encryptAttachment(attachment.data, proto.key, iv)
.then(
function(result) {
return this.server
.putAttachment(result.ciphertext)
.then(function(id) {
proto.id = id;
proto.contentType = attachment.contentType;
proto.digest = result.digest;
@ -170,7 +190,8 @@ MessageSender.prototype = {
}
return proto;
});
}.bind(this));
}.bind(this)
);
},
retransmitMessage: function(number, jsonData, timestamp) {
@ -191,7 +212,14 @@ MessageSender.prototype = {
// It's most likely that dataMessage will be populated, so we look at it in detail
var data = content.dataMessage;
if (data && !data.attachments.length && !data.body && !data.expireTimer && !data.flags && !data.group) {
if (
data &&
!data.attachments.length &&
!data.body &&
!data.expireTimer &&
!data.flags &&
!data.group
) {
return false;
}
@ -231,23 +259,33 @@ MessageSender.prototype = {
},
queueJobForNumber: function(number, runJob) {
var taskWithTimeout = textsecure.createTaskWithTimeout(runJob, 'queueJobForNumber ' + number);
var taskWithTimeout = textsecure.createTaskWithTimeout(
runJob,
'queueJobForNumber ' + number
);
var runPrevious = this.pendingMessages[number] || Promise.resolve();
var runCurrent = this.pendingMessages[number] = runPrevious.then(taskWithTimeout, taskWithTimeout);
runCurrent.then(function() {
var runCurrent = (this.pendingMessages[number] = runPrevious.then(
taskWithTimeout,
taskWithTimeout
));
runCurrent.then(
function() {
if (this.pendingMessages[number] === runCurrent) {
delete this.pendingMessages[number];
}
}.bind(this));
}.bind(this)
);
},
uploadAttachments: function(message) {
return Promise.all(
message.attachments.map(this.makeAttachmentPointer.bind(this))
).then(function(attachmentPointers) {
)
.then(function(attachmentPointers) {
message.attachmentPointers = attachmentPointers;
}).catch(function(error) {
})
.catch(function(error) {
if (error instanceof Error && error.name === 'HTTPError') {
throw new textsecure.MessageError(message, error);
} else {
@ -264,7 +302,8 @@ MessageSender.prototype = {
return Promise.resolve();
}
return Promise.all(quote.attachments.map(function(attachment) {
return Promise.all(
quote.attachments.map(function(attachment) {
const thumbnail = attachment.thumbnail;
if (!thumbnail) {
return;
@ -273,7 +312,8 @@ MessageSender.prototype = {
return makePointer(thumbnail).then(function(pointer) {
attachment.attachmentPointer = pointer;
});
})).catch(function(error) {
})
).catch(function(error) {
if (error instanceof Error && error.name === 'HTTPError') {
throw new textsecure.MessageError(message, error);
} else {
@ -287,8 +327,10 @@ MessageSender.prototype = {
return Promise.all([
this.uploadAttachments(message),
this.uploadThumbnails(message),
]).then(function() {
return new Promise(function(resolve, reject) {
]).then(
function() {
return new Promise(
function(resolve, reject) {
this.sendMessageProto(
message.timestamp,
message.recipients,
@ -302,27 +344,43 @@ MessageSender.prototype = {
}
}
);
}.bind(this));
}.bind(this));
}.bind(this)
);
}.bind(this)
);
},
sendMessageProto: function(timestamp, numbers, message, callback, silent) {
var rejections = textsecure.storage.get('signedKeyRotationRejected', 0);
if (rejections > 5) {
throw new textsecure.SignedPreKeyRotationError(numbers, message.toArrayBuffer(), timestamp);
throw new textsecure.SignedPreKeyRotationError(
numbers,
message.toArrayBuffer(),
timestamp
);
}
var outgoing = new OutgoingMessage(this.server, timestamp, numbers, message, silent, callback);
var outgoing = new OutgoingMessage(
this.server,
timestamp,
numbers,
message,
silent,
callback
);
numbers.forEach(function(number) {
numbers.forEach(
function(number) {
this.queueJobForNumber(number, function() {
return outgoing.sendToNumber(number);
});
}.bind(this));
}.bind(this)
);
},
retrySendMessageProto: function(numbers, encodedMessage, timestamp) {
var proto = textsecure.protobuf.DataMessage.decode(encodedMessage);
return new Promise(function(resolve, reject) {
return new Promise(
function(resolve, reject) {
this.sendMessageProto(timestamp, numbers, proto, function(res) {
if (res.errors.length > 0) {
reject(res);
@ -330,11 +388,13 @@ MessageSender.prototype = {
resolve(res);
}
});
}.bind(this));
}.bind(this)
);
},
sendIndividualProto: function(number, proto, timestamp, silent) {
return new Promise(function(resolve, reject) {
return new Promise(
function(resolve, reject) {
var callback = function(res) {
if (res.errors.length > 0) {
reject(res);
@ -343,7 +403,8 @@ MessageSender.prototype = {
}
};
this.sendMessageProto(timestamp, [number], proto, callback, silent);
}.bind(this));
}.bind(this)
);
},
createSyncMessage: function() {
@ -359,14 +420,21 @@ MessageSender.prototype = {
return syncMessage;
},
sendSyncMessage: function(encodedDataMessage, timestamp, destination, expirationStartTimestamp) {
sendSyncMessage: function(
encodedDataMessage,
timestamp,
destination,
expirationStartTimestamp
) {
var myNumber = textsecure.storage.user.getNumber();
var myDevice = textsecure.storage.user.getDeviceId();
if (myDevice == 1) {
return Promise.resolve();
}
var dataMessage = textsecure.protobuf.DataMessage.decode(encodedDataMessage);
var dataMessage = textsecure.protobuf.DataMessage.decode(
encodedDataMessage
);
var sentMessage = new textsecure.protobuf.SyncMessage.Sent();
sentMessage.timestamp = timestamp;
sentMessage.message = dataMessage;
@ -382,7 +450,12 @@ MessageSender.prototype = {
contentMessage.syncMessage = syncMessage;
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, Date.now(), silent);
return this.sendIndividualProto(
myNumber,
contentMessage,
Date.now(),
silent
);
},
getProfile: function(number) {
@ -404,7 +477,12 @@ MessageSender.prototype = {
contentMessage.syncMessage = syncMessage;
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, Date.now(), silent);
return this.sendIndividualProto(
myNumber,
contentMessage,
Date.now(),
silent
);
}
return Promise.resolve();
@ -421,7 +499,12 @@ MessageSender.prototype = {
contentMessage.syncMessage = syncMessage;
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, Date.now(), silent);
return this.sendIndividualProto(
myNumber,
contentMessage,
Date.now(),
silent
);
}
return Promise.resolve();
@ -439,7 +522,12 @@ MessageSender.prototype = {
contentMessage.syncMessage = syncMessage;
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, Date.now(), silent);
return this.sendIndividualProto(
myNumber,
contentMessage,
Date.now(),
silent
);
}
return Promise.resolve();
@ -471,7 +559,12 @@ MessageSender.prototype = {
contentMessage.syncMessage = syncMessage;
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, Date.now(), silent);
return this.sendIndividualProto(
myNumber,
contentMessage,
Date.now(),
silent
);
}
return Promise.resolve();
@ -501,7 +594,8 @@ MessageSender.prototype = {
// We want the NullMessage to look like a normal outgoing message; not silent
const promise = this.sendIndividualProto(destination, contentMessage, now);
return promise.then(function() {
return promise.then(
function() {
var verified = new textsecure.protobuf.Verified();
verified.state = state;
verified.destination = destination;
@ -516,18 +610,22 @@ MessageSender.prototype = {
var silent = true;
return this.sendIndividualProto(myNumber, contentMessage, now, silent);
}.bind(this));
}.bind(this)
);
},
sendGroupProto: function(numbers, proto, timestamp) {
timestamp = timestamp || Date.now();
var me = textsecure.storage.user.getNumber();
numbers = numbers.filter(function(number) { return number != me; });
numbers = numbers.filter(function(number) {
return number != me;
});
if (numbers.length === 0) {
return Promise.reject(new Error('No other members in the group'));
}
return new Promise(function(resolve, reject) {
return new Promise(
function(resolve, reject) {
var silent = true;
var callback = function(res) {
res.dataMessage = proto.toArrayBuffer();
@ -539,10 +637,19 @@ MessageSender.prototype = {
}.bind(this);
this.sendMessageProto(timestamp, numbers, proto, callback, silent);
}.bind(this));
}.bind(this)
);
},
sendMessageToNumber: function(number, messageText, attachments, quote, timestamp, expireTimer, profileKey) {
sendMessageToNumber: function(
number,
messageText,
attachments,
quote,
timestamp,
expireTimer,
profileKey
) {
return this.sendMessage({
recipients: [number],
body: messageText,
@ -551,69 +658,87 @@ MessageSender.prototype = {
quote: quote,
needsSync: true,
expireTimer: expireTimer,
profileKey : profileKey
profileKey: profileKey,
});
},
resetSession: function(number, timestamp) {
console.log('resetting secure session');
var proto = new textsecure.protobuf.DataMessage();
proto.body = "TERMINATE";
proto.body = 'TERMINATE';
proto.flags = textsecure.protobuf.DataMessage.Flags.END_SESSION;
var logError = function(prefix) {
return function(error) {
console.log(
prefix,
error && error.stack ? error.stack : error
);
console.log(prefix, error && error.stack ? error.stack : error);
throw error;
};
};
var deleteAllSessions = function(number) {
return textsecure.storage.protocol.getDeviceIds(number)
return textsecure.storage.protocol
.getDeviceIds(number)
.then(function(deviceIds) {
return Promise.all(deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
return Promise.all(
deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(
number,
deviceId
);
console.log('deleting sessions for', address.toString());
var sessionCipher = new libsignal.SessionCipher(
textsecure.storage.protocol,
address
);
return sessionCipher.deleteAllSessionsForDevice();
}));
})
);
});
};
var sendToContact = deleteAllSessions(number)
.catch(logError('resetSession/deleteAllSessions1 error:'))
.then(
function() {
console.log(
'finished closing local sessions, now sending to contact'
);
return this.sendIndividualProto(number, proto, timestamp).catch(
logError('resetSession/sendToContact error:')
);
}.bind(this)
)
.then(function() {
console.log('finished closing local sessions, now sending to contact');
return this.sendIndividualProto(number, proto, timestamp)
.catch(logError('resetSession/sendToContact error:'))
}.bind(this))
.then(function() {
return deleteAllSessions(number)
.catch(logError('resetSession/deleteAllSessions2 error:'));
return deleteAllSessions(number).catch(
logError('resetSession/deleteAllSessions2 error:')
);
});
var buffer = proto.toArrayBuffer();
var sendSync = this.sendSyncMessage(buffer, timestamp, number)
.catch(logError('resetSession/sendSync error:'));
var sendSync = this.sendSyncMessage(buffer, timestamp, number).catch(
logError('resetSession/sendSync error:')
);
return Promise.all([
sendToContact,
sendSync
]);
return Promise.all([sendToContact, sendSync]);
},
sendMessageToGroup: function(groupId, messageText, attachments, quote, timestamp, expireTimer, profileKey) {
return textsecure.storage.groups.getNumbers(groupId).then(function(numbers) {
sendMessageToGroup: function(
groupId,
messageText,
attachments,
quote,
timestamp,
expireTimer,
profileKey
) {
return textsecure.storage.groups.getNumbers(groupId).then(
function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
var me = textsecure.storage.user.getNumber();
numbers = numbers.filter(function(number) { return number != me; });
numbers = numbers.filter(function(number) {
return number != me;
});
if (numbers.length === 0) {
return Promise.reject(new Error('No other members in the group'));
}
@ -629,17 +754,19 @@ MessageSender.prototype = {
profileKey: profileKey,
group: {
id: groupId,
type: textsecure.protobuf.GroupContext.Type.DELIVER
}
type: textsecure.protobuf.GroupContext.Type.DELIVER,
},
});
}.bind(this));
}.bind(this)
);
},
createGroup: function(numbers, name, avatar) {
var proto = new textsecure.protobuf.DataMessage();
proto.group = new textsecure.protobuf.GroupContext();
return textsecure.storage.groups.createNewGroup(numbers).then(function(group) {
return textsecure.storage.groups.createNewGroup(numbers).then(
function(group) {
proto.group.id = stringToArrayBuffer(group.id);
var numbers = group.numbers;
@ -647,13 +774,16 @@ MessageSender.prototype = {
proto.group.members = numbers;
proto.group.name = name;
return this.makeAttachmentPointer(avatar).then(function(attachment) {
return this.makeAttachmentPointer(avatar).then(
function(attachment) {
proto.group.avatar = attachment;
return this.sendGroupProto(numbers, proto).then(function() {
return proto.group.id;
});
}.bind(this));
}.bind(this));
}.bind(this)
);
}.bind(this)
);
},
updateGroup: function(groupId, name, avatar, numbers) {
@ -664,19 +794,23 @@ MessageSender.prototype = {
proto.group.type = textsecure.protobuf.GroupContext.Type.UPDATE;
proto.group.name = name;
return textsecure.storage.groups.addNumbers(groupId, numbers).then(function(numbers) {
return textsecure.storage.groups.addNumbers(groupId, numbers).then(
function(numbers) {
if (numbers === undefined) {
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
}
proto.group.members = numbers;
return this.makeAttachmentPointer(avatar).then(function(attachment) {
return this.makeAttachmentPointer(avatar).then(
function(attachment) {
proto.group.avatar = attachment;
return this.sendGroupProto(numbers, proto).then(function() {
return proto.group.id;
});
}.bind(this));
}.bind(this));
}.bind(this)
);
}.bind(this)
);
},
addNumberToGroup: function(groupId, number) {
@ -685,13 +819,15 @@ MessageSender.prototype = {
proto.group.id = stringToArrayBuffer(groupId);
proto.group.type = textsecure.protobuf.GroupContext.Type.UPDATE;
return textsecure.storage.groups.addNumbers(groupId, [number]).then(function(numbers) {
return textsecure.storage.groups.addNumbers(groupId, [number]).then(
function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
proto.group.members = numbers;
return this.sendGroupProto(numbers, proto);
}.bind(this));
}.bind(this)
);
},
setGroupName: function(groupId, name) {
@ -701,13 +837,15 @@ MessageSender.prototype = {
proto.group.type = textsecure.protobuf.GroupContext.Type.UPDATE;
proto.group.name = name;
return textsecure.storage.groups.getNumbers(groupId).then(function(numbers) {
return textsecure.storage.groups.getNumbers(groupId).then(
function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
proto.group.members = numbers;
return this.sendGroupProto(numbers, proto);
}.bind(this));
}.bind(this)
);
},
setGroupAvatar: function(groupId, avatar) {
@ -716,16 +854,20 @@ MessageSender.prototype = {
proto.group.id = stringToArrayBuffer(groupId);
proto.group.type = textsecure.protobuf.GroupContext.Type.UPDATE;
return textsecure.storage.groups.getNumbers(groupId).then(function(numbers) {
return textsecure.storage.groups.getNumbers(groupId).then(
function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
proto.group.members = numbers;
return this.makeAttachmentPointer(avatar).then(function(attachment) {
return this.makeAttachmentPointer(avatar).then(
function(attachment) {
proto.group.avatar = attachment;
return this.sendGroupProto(numbers, proto);
}.bind(this));
}.bind(this));
}.bind(this)
);
}.bind(this)
);
},
leaveGroup: function(groupId) {
@ -734,21 +876,33 @@ MessageSender.prototype = {
proto.group.id = stringToArrayBuffer(groupId);
proto.group.type = textsecure.protobuf.GroupContext.Type.QUIT;
return textsecure.storage.groups.getNumbers(groupId).then(function(numbers) {
return textsecure.storage.groups
.getNumbers(groupId)
.then(function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return textsecure.storage.groups.deleteGroup(groupId).then(function() {
return Promise.reject(new Error('Unknown Group'));
return textsecure.storage.groups.deleteGroup(groupId).then(
function() {
return this.sendGroupProto(numbers, proto);
}.bind(this));
}.bind(this)
);
});
},
sendExpirationTimerUpdateToGroup: function(groupId, expireTimer, timestamp, profileKey) {
return textsecure.storage.groups.getNumbers(groupId).then(function(numbers) {
sendExpirationTimerUpdateToGroup: function(
groupId,
expireTimer,
timestamp,
profileKey
) {
return textsecure.storage.groups.getNumbers(groupId).then(
function(numbers) {
if (numbers === undefined)
return Promise.reject(new Error("Unknown Group"));
return Promise.reject(new Error('Unknown Group'));
var me = textsecure.storage.user.getNumber();
numbers = numbers.filter(function(number) { return number != me; });
numbers = numbers.filter(function(number) {
return number != me;
});
if (numbers.length === 0) {
return Promise.reject(new Error('No other members in the group'));
}
@ -761,12 +915,18 @@ MessageSender.prototype = {
flags: textsecure.protobuf.DataMessage.Flags.EXPIRATION_TIMER_UPDATE,
group: {
id: groupId,
type: textsecure.protobuf.GroupContext.Type.DELIVER
}
});
}.bind(this));
type: textsecure.protobuf.GroupContext.Type.DELIVER,
},
sendExpirationTimerUpdateToNumber: function(number, expireTimer, timestamp, profileKey) {
});
}.bind(this)
);
},
sendExpirationTimerUpdateToNumber: function(
number,
expireTimer,
timestamp,
profileKey
) {
var proto = new textsecure.protobuf.DataMessage();
return this.sendMessage({
recipients: [number],
@ -774,25 +934,47 @@ MessageSender.prototype = {
needsSync: true,
expireTimer: expireTimer,
profileKey: profileKey,
flags : textsecure.protobuf.DataMessage.Flags.EXPIRATION_TIMER_UPDATE
flags: textsecure.protobuf.DataMessage.Flags.EXPIRATION_TIMER_UPDATE,
});
}
},
};
window.textsecure = window.textsecure || {};
textsecure.MessageSender = function(url, username, password, cdn_url) {
var sender = new MessageSender(url, username, password, cdn_url);
textsecure.replay.registerFunction(sender.tryMessageAgain.bind(sender), textsecure.replay.Type.ENCRYPT_MESSAGE);
textsecure.replay.registerFunction(sender.retransmitMessage.bind(sender), textsecure.replay.Type.TRANSMIT_MESSAGE);
textsecure.replay.registerFunction(sender.sendMessage.bind(sender), textsecure.replay.Type.REBUILD_MESSAGE);
textsecure.replay.registerFunction(sender.retrySendMessageProto.bind(sender), textsecure.replay.Type.RETRY_SEND_MESSAGE_PROTO);
textsecure.replay.registerFunction(
sender.tryMessageAgain.bind(sender),
textsecure.replay.Type.ENCRYPT_MESSAGE
);
textsecure.replay.registerFunction(
sender.retransmitMessage.bind(sender),
textsecure.replay.Type.TRANSMIT_MESSAGE
);
textsecure.replay.registerFunction(
sender.sendMessage.bind(sender),
textsecure.replay.Type.REBUILD_MESSAGE
);
textsecure.replay.registerFunction(
sender.retrySendMessageProto.bind(sender),
textsecure.replay.Type.RETRY_SEND_MESSAGE_PROTO
);
this.sendExpirationTimerUpdateToNumber = sender.sendExpirationTimerUpdateToNumber.bind(sender);
this.sendExpirationTimerUpdateToGroup = sender.sendExpirationTimerUpdateToGroup .bind(sender);
this.sendRequestGroupSyncMessage = sender.sendRequestGroupSyncMessage .bind(sender);
this.sendRequestContactSyncMessage = sender.sendRequestContactSyncMessage .bind(sender);
this.sendRequestConfigurationSyncMessage = sender.sendRequestConfigurationSyncMessage.bind(sender);
this.sendExpirationTimerUpdateToNumber = sender.sendExpirationTimerUpdateToNumber.bind(
sender
);
this.sendExpirationTimerUpdateToGroup = sender.sendExpirationTimerUpdateToGroup.bind(
sender
);
this.sendRequestGroupSyncMessage = sender.sendRequestGroupSyncMessage.bind(
sender
);
this.sendRequestContactSyncMessage = sender.sendRequestContactSyncMessage.bind(
sender
);
this.sendRequestConfigurationSyncMessage = sender.sendRequestConfigurationSyncMessage.bind(
sender
);
this.sendMessageToNumber = sender.sendMessageToNumber.bind(sender);
this.resetSession = sender.resetSession.bind(sender);
this.sendMessageToGroup = sender.sendMessageToGroup.bind(sender);
@ -811,5 +993,5 @@ textsecure.MessageSender = function(url, username, password, cdn_url) {
};
textsecure.MessageSender.prototype = {
constructor: textsecure.MessageSender
constructor: textsecure.MessageSender,
};

16
libtextsecure/storage.js
View file

@ -1,7 +1,6 @@
'use strict';
;(function() {
(function() {
/************************************************
*** Utilities to store data in local storage ***
************************************************/
@ -14,20 +13,18 @@
*** Base Storage Routines ***
*****************************/
put: function(key, value) {
if (value === undefined)
throw new Error("Tried to store undefined");
localStorage.setItem("" + key, textsecure.utils.jsonThing(value));
if (value === undefined) throw new Error('Tried to store undefined');
localStorage.setItem('' + key, textsecure.utils.jsonThing(value));
},
get: function(key, defaultValue) {
var value = localStorage.getItem("" + key);
if (value === null)
return defaultValue;
var value = localStorage.getItem('' + key);
if (value === null) return defaultValue;
return JSON.parse(value);
},
remove: function(key) {
localStorage.removeItem("" + key);
localStorage.removeItem('' + key);
},
};
@ -43,4 +40,3 @@
return textsecure.storage.impl.remove(key);
};
})();

92
libtextsecure/storage/groups.js
View file

@ -1,4 +1,4 @@
;(function() {
(function() {
'use strict';
/*********************
@ -25,15 +25,19 @@
var groupId = groupId;
return new Promise(function(resolve) {
if (groupId !== undefined) {
resolve(textsecure.storage.protocol.getGroup(groupId).then(function(group) {
resolve(
textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group !== undefined) {
throw new Error("Tried to recreate group");
throw new Error('Tried to recreate group');
}
}));
})
);
} else {
resolve(generateNewGroupId().then(function(newGroupId) {
resolve(
generateNewGroupId().then(function(newGroupId) {
groupId = newGroupId;
}));
})
);
}
}).then(function() {
var me = textsecure.storage.user.getNumber();
@ -42,49 +46,54 @@
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);
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);
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 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 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;
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");
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 textsecure.storage.protocol
.putGroup(groupId, group)
.then(function() {
return group.numbers;
});
}
@ -94,21 +103,24 @@
},
addNumbers: function(groupId, numbers) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
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");
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 textsecure.storage.protocol
.putGroup(groupId, group)
.then(function() {
return group.numbers;
});
});
@ -119,26 +131,34 @@
},
getGroup: function(groupId) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
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) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined)
throw new Error("Tried to update numbers for unknown group");
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");
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; });
var added = numbers.filter(function(number) {
return group.numbers.indexOf(number) < 0;
});
return textsecure.storage.groups.addNumbers(groupId, added);
});
}
},
};
})();

2
libtextsecure/storage/unprocessed.js
View file

@ -1,4 +1,4 @@
;(function() {
(function() {
'use strict';
/*****************************************

20
libtextsecure/storage/user.js
View file

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

97
libtextsecure/stringview.js
View file

@ -1,8 +1,7 @@
;(function() {
"use strict";
(function() {
'use strict';
window.StringView = {
/*
* These functions from the Mozilla Developer Network
* and have been placed in the public domain.
@ -11,33 +10,39 @@
*/
b64ToUint6: function(nChr) {
return nChr > 64 && nChr < 91 ?
nChr - 65
: nChr > 96 && nChr < 123 ?
nChr - 71
: nChr > 47 && nChr < 58 ?
nChr + 4
: nChr === 43 ?
62
: nChr === 47 ?
63
:
0;
return nChr > 64 && nChr < 91
? nChr - 65
: nChr > 96 && nChr < 123
? nChr - 71
: nChr > 47 && nChr < 58
? nChr + 4
: nChr === 43
? 62
: nChr === 47
? 63
: 0;
},
base64ToBytes: function(sBase64, nBlocksSize) {
var
sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ""), nInLen = sB64Enc.length,
nOutLen = nBlocksSize ? Math.ceil((nInLen * 3 + 1 >> 2) / nBlocksSize) * nBlocksSize : nInLen * 3 + 1 >> 2;
var sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ''),
nInLen = sB64Enc.length,
nOutLen = nBlocksSize
? Math.ceil(((nInLen * 3 + 1) >> 2) / nBlocksSize) * nBlocksSize
: (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 (
var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0;
nInIdx < nInLen;
nInIdx++
) {
nMod4 = nInIdx & 3;
nUint24 |= StringView.b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << 18 - 6 * nMod4;
nUint24 |=
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;
taBytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255;
}
nUint24 = 0;
}
@ -46,37 +51,43 @@
},
uint6ToB64: function(nUint6) {
return nUint6 < 26 ?
nUint6 + 65
: nUint6 < 52 ?
nUint6 + 71
: nUint6 < 62 ?
nUint6 - 4
: nUint6 === 62 ?
43
: nUint6 === 63 ?
47
:
65;
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++) {
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 (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 >>> 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 sB64Enc.replace(/A(?=A$|$)/g, '=');
},
};
}());
})();

30
libtextsecure/sync_request.js
View file

@ -1,10 +1,15 @@
;(function () {
(function() {
'use strict';
window.textsecure = window.textsecure || {};
function SyncRequest(sender, receiver) {
if (!(sender instanceof textsecure.MessageSender) || !(receiver instanceof textsecure.MessageReceiver)) {
throw new Error('Tried to construct a SyncRequest without MessageSender and MessageReceiver');
if (
!(sender instanceof textsecure.MessageSender) ||
!(receiver instanceof textsecure.MessageReceiver)
) {
throw new Error(
'Tried to construct a SyncRequest without MessageSender and MessageReceiver'
);
}
this.receiver = receiver;
@ -15,10 +20,13 @@
receiver.addEventListener('groupsync', this.ongroup);
console.log('SyncRequest created. Sending contact sync message...');
sender.sendRequestContactSyncMessage().then(function() {
sender
.sendRequestContactSyncMessage()
.then(function() {
console.log('SyncRequest now sending group sync messsage...');
return sender.sendRequestGroupSyncMessage();
}).catch(function(error) {
})
.catch(function(error) {
console.log(
'SyncRequest error:',
error && error.stack ? error.stack : error
@ -57,18 +65,18 @@
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);
this.removeEventListener = syncRequest.removeEventListener.bind(
syncRequest
);
};
textsecure.SyncRequest.prototype = {
constructor: textsecure.SyncRequest
constructor: textsecure.SyncRequest,
};
}());
})();

18
libtextsecure/task_with_timeout.js
View file

@ -3,23 +3,26 @@
window.textsecure.createTaskWithTimeout = function(task, id, 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');
return function() {
return new Promise(function(resolve, reject) {
var complete = false;
var timer = setTimeout(function() {
var timer = setTimeout(
function() {
if (!complete) {
var message =
(id || '')
+ ' task did not complete in time. Calling stack: '
+ errorForStack.stack;
(id || '') +
' task did not complete in time. Calling stack: ' +
errorForStack.stack;
console.log(message);
return reject(new Error(message));
}
}.bind(this), options.timeout);
}.bind(this),
options.timeout
);
var clearTimer = function() {
try {
var localTimer = timer;
@ -27,8 +30,7 @@
timer = null;
clearTimeout(localTimer);
}
}
catch (error) {
} catch (error) {
console.log(
id || '',
'task ran into problem canceling timer. Calling stack:',

10
libtextsecure/test/_test.js
View file

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

64
libtextsecure/test/account_manager_test.js
View file

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

33
libtextsecure/test/contacts_parser_test.js
View file

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

44
libtextsecure/test/crypto_test.js
View file

@ -6,10 +6,17 @@ describe('encrypting and decrypting profile data', function() {
var buffer = dcodeIO.ByteBuffer.wrap(name).toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfileName(buffer, key).then(function(encrypted) {
return textsecure.crypto
.encryptProfileName(buffer, key)
.then(function(encrypted) {
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');
return textsecure.crypto
.decryptProfileName(encrypted, key)
.then(function(decrypted) {
assert.strictEqual(
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
'Alice'
);
});
});
});
@ -17,11 +24,18 @@ describe('encrypting and decrypting profile data', function() {
var name = dcodeIO.ByteBuffer.wrap('').toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfileName(name.buffer, key).then(function(encrypted) {
return textsecure.crypto
.encryptProfileName(name.buffer, key)
.then(function(encrypted) {
assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12);
return textsecure.crypto.decryptProfileName(encrypted, key).then(function(decrypted) {
return textsecure.crypto
.decryptProfileName(encrypted, key)
.then(function(decrypted) {
assert.strictEqual(decrypted.byteLength, 0);
assert.strictEqual(dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'), '');
assert.strictEqual(
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
''
);
});
});
});
@ -31,10 +45,14 @@ describe('encrypting and decrypting profile data', function() {
var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfile(buffer, key).then(function(encrypted) {
return textsecure.crypto
.encryptProfile(buffer, key)
.then(function(encrypted) {
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
return textsecure.crypto.decryptProfile(encrypted, key).then(function(decrypted) {
assertEqualArrayBuffers(buffer, decrypted)
return textsecure.crypto
.decryptProfile(encrypted, key)
.then(function(decrypted) {
assertEqualArrayBuffers(buffer, decrypted);
});
});
});
@ -43,9 +61,13 @@ describe('encrypting and decrypting profile data', function() {
var key = libsignal.crypto.getRandomBytes(32);
var bad_key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfile(buffer, key).then(function(encrypted) {
return textsecure.crypto
.encryptProfile(buffer, key)
.then(function(encrypted) {
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
return textsecure.crypto.decryptProfile(encrypted, bad_key).catch(function(error) {
return textsecure.crypto
.decryptProfile(encrypted, bad_key)
.catch(function(error) {
assert.strictEqual(error.name, 'ProfileDecryptError');
});
});

15
libtextsecure/test/fake_api.js
View file

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

69
libtextsecure/test/generate_keys_test.js
View file

@ -1,6 +1,6 @@
'use strict';
describe("Key generation", function() {
describe('Key generation', function() {
var count = 10;
this.timeout(count * 2000);
@ -15,34 +15,46 @@ describe("Key generation", function() {
}
function itStoresPreKey(keyId) {
it('prekey ' + keyId + ' is valid', function(done) {
return textsecure.storage.protocol.loadPreKey(keyId).then(function(keyPair) {
return textsecure.storage.protocol
.loadPreKey(keyId)
.then(function(keyPair) {
validateStoredKeyPair(keyPair);
}).then(done,done);
})
.then(done, done);
});
}
function itStoresSignedPreKey(keyId) {
it('signed prekey ' + keyId + ' is valid', function(done) {
return textsecure.storage.protocol.loadSignedPreKey(keyId).then(function(keyPair) {
return textsecure.storage.protocol
.loadSignedPreKey(keyId)
.then(function(keyPair) {
validateStoredKeyPair(keyPair);
}).then(done,done);
})
.then(done, done);
});
}
function validateResultKey(resultKey) {
return textsecure.storage.protocol.loadPreKey(resultKey.keyId).then(function(keyPair) {
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) {
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) {
libsignal.KeyHelper.generateIdentityKeyPair()
.then(function(keyPair) {
return textsecure.storage.protocol.put('identityKey', keyPair);
}).then(done, done);
})
.then(done, done);
});
describe('the first time', function() {
@ -56,9 +68,12 @@ describe("Key generation", function() {
*/
before(function(done) {
var accountManager = new textsecure.AccountManager('');
accountManager.generateKeys(count).then(function(res) {
accountManager
.generateKeys(count)
.then(function(res) {
result = res;
}).then(done,done);
})
.then(done, done);
});
for (var i = 1; i <= count; i++) {
itStoresPreKey(i);
@ -78,9 +93,11 @@ describe("Key generation", function() {
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
Promise.all(result.preKeys.map(validateResultKey))
.then(function() {
done();
}).catch(done);
})
.catch(done);
});
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 1);
@ -92,9 +109,12 @@ describe("Key generation", function() {
var result;
before(function(done) {
var accountManager = new textsecure.AccountManager('');
accountManager.generateKeys(count).then(function(res) {
accountManager
.generateKeys(count)
.then(function(res) {
result = res;
}).then(done,done);
})
.then(done, done);
});
for (var i = 1; i <= 2 * count; i++) {
itStoresPreKey(i);
@ -114,9 +134,11 @@ describe("Key generation", function() {
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
Promise.all(result.preKeys.map(validateResultKey))
.then(function() {
done();
}).catch(done);
})
.catch(done);
});
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 2);
@ -128,9 +150,12 @@ describe("Key generation", function() {
var result;
before(function(done) {
var accountManager = new textsecure.AccountManager('');
accountManager.generateKeys(count).then(function(res) {
accountManager
.generateKeys(count)
.then(function(res) {
result = res;
}).then(done,done);
})
.then(done, done);
});
for (var i = 1; i <= 3 * count; i++) {
itStoresPreKey(i);
@ -150,9 +175,11 @@ describe("Key generation", function() {
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
Promise.all(result.preKeys.map(validateResultKey))
.then(function() {
done();
}).catch(done);
})
.catch(done);
});
it('result contains a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 3);

12
libtextsecure/test/helpers_test.js
View file

@ -1,18 +1,18 @@
'use strict';
describe("Helpers", function() {
describe("ArrayBuffer->String conversion", function() {
describe('Helpers', function() {
describe('ArrayBuffer->String conversion', function() {
it('works', function() {
var b = new ArrayBuffer(3);
var a = new Uint8Array(b);
a[0] = 0;
a[1] = 255;
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() {
var StaticArrayBufferProto = new ArrayBuffer().__proto__;
var anArrayBuffer = new ArrayBuffer(1);
@ -23,7 +23,9 @@ describe("Helpers", function() {
it('throws an error when passed a non string', function() {
var notStringable = [{}, undefined, null, new ArrayBuffer()];
notStringable.forEach(function(notString) {
assert.throw(function() { stringToArrayBuffer(notString) }, Error);
assert.throw(function() {
stringToArrayBuffer(notString);
}, Error);
});
});
});

113
libtextsecure/test/in_memory_signal_protocol_store.js
View file

@ -11,13 +11,18 @@ SignalProtocolStore.prototype = {
return Promise.resolve(this.get('registrationId'));
},
put: function(key, value) {
if (key === undefined || value === undefined || key === null || value === null)
throw new Error("Tried to store undefined/null");
if (
key === undefined ||
value === undefined ||
key === null ||
value === null
)
throw new Error('Tried to store undefined/null');
this.store[key] = value;
},
get: function(key, defaultValue) {
if (key === null || key === undefined)
throw new Error("Tried to get value for undefined/null key");
throw new Error('Tried to get value for undefined/null key');
if (key in this.store) {
return this.store[key];
} else {
@ -26,16 +31,16 @@ SignalProtocolStore.prototype = {
},
remove: function(key) {
if (key === null || key === undefined)
throw new Error("Tried to remove value for undefined/null key");
throw new Error('Tried to remove value for undefined/null key');
delete this.store[key];
},
isTrustedIdentity: function(identifier, identityKey) {
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)) {
throw new error("Expected identityKey to be an ArrayBuffer");
throw new error('Expected identityKey to be an ArrayBuffer');
}
var trusted = this.get('identityKey' + identifier);
if (trusted === undefined) {
@ -45,15 +50,18 @@ SignalProtocolStore.prototype = {
},
loadIdentityKey: function(identifier) {
if (identifier === null || identifier === undefined)
throw new Error("Tried to get identity key for undefined/null key");
return new Promise(function(resolve) {
throw new Error('Tried to get identity key for undefined/null key');
return new Promise(
function(resolve) {
resolve(this.get('identityKey' + identifier));
}.bind(this));
}.bind(this)
);
},
saveIdentity: function(identifier, identityKey) {
if (identifier === null || identifier === undefined)
throw new Error("Tried to put identity key for undefined/null key");
return new Promise(function(resolve) {
throw new Error('Tried to put identity key for undefined/null key');
return new Promise(
function(resolve) {
var existing = this.get('identityKey' + identifier);
this.put('identityKey' + identifier, identityKey);
if (existing && existing !== identityKey) {
@ -61,36 +69,46 @@ SignalProtocolStore.prototype = {
} else {
resolve(false);
}
}.bind(this));
}.bind(this)
);
},
/* Returns a prekeypair object or undefined */
loadPreKey: function(keyId) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
var res = this.get('25519KeypreKey' + keyId);
resolve(res);
}.bind(this));
}.bind(this)
);
},
storePreKey: function(keyId, keyPair) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.put('25519KeypreKey' + keyId, keyPair));
}.bind(this));
}.bind(this)
);
},
removePreKey: function(keyId) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.remove('25519KeypreKey' + keyId));
}.bind(this));
}.bind(this)
);
},
/* Returns a signed keypair object or undefined */
loadSignedPreKey: function(keyId) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
var res = this.get('25519KeysignedKey' + keyId);
resolve(res);
}.bind(this));
}.bind(this)
);
},
loadSignedPreKeys: function() {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
var res = [];
for (var i in this.store) {
if (i.startsWith('25519KeysignedKey')) {
@ -98,48 +116,69 @@ SignalProtocolStore.prototype = {
}
}
resolve(res);
}.bind(this));
}.bind(this)
);
},
storeSignedPreKey: function(keyId, keyPair) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.put('25519KeysignedKey' + keyId, keyPair));
}.bind(this));
}.bind(this)
);
},
removeSignedPreKey: function(keyId) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.remove('25519KeysignedKey' + keyId));
}.bind(this));
}.bind(this)
);
},
loadSession: function(identifier) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.get('session' + identifier));
}.bind(this));
}.bind(this)
);
},
storeSession: function(identifier, record) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
resolve(this.put('session' + identifier, record));
}.bind(this));
}.bind(this)
);
},
removeAllSessions: function(identifier) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
for (key in this.store) {
if (key.match(RegExp('^session' + identifier.replace('\+','\\\+') + '.+'))) {
if (
key.match(
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
)
) {
delete this.store[key];
}
}
resolve();
}.bind(this));
}.bind(this)
);
},
getDeviceIds: function(identifier) {
return new Promise(function(resolve) {
return new Promise(
function(resolve) {
var deviceIds = [];
for (key in this.store) {
if (key.match(RegExp('^session' + identifier.replace('\+','\\\+') + '.+'))) {
if (
key.match(
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
)
) {
deviceIds.push(parseInt(key.split('.')[1]));
}
}
resolve(deviceIds);
}.bind(this));
}
}.bind(this)
);
},
};

50
libtextsecure/test/message_receiver_test.js
View file

@ -7,10 +7,12 @@ describe('MessageReceiver', function() {
before(function() {
window.WebSocket = MockSocket;
textsecure.storage.user.setNumberAndDeviceId(number, deviceId, 'name');
textsecure.storage.put("password", "password");
textsecure.storage.put("signaling_key", signalingKey);
textsecure.storage.put('password', 'password');
textsecure.storage.put('signaling_key', signalingKey);
});
after(function() {
window.WebSocket = WebSocket;
});
after (function() { window.WebSocket = WebSocket; });
describe('connecting', function() {
var blob = null;
@ -22,7 +24,7 @@ describe('MessageReceiver', function() {
};
var websocketmessage = new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: { verb: 'PUT', path: '/messages' }
request: { verb: 'PUT', path: '/messages' },
});
before(function(done) {
@ -33,13 +35,32 @@ describe('MessageReceiver', function() {
var aes_key = signaling_key.slice(0, 32);
var mac_key = signaling_key.slice(32, 32 + 20);
window.crypto.subtle.importKey('raw', aes_key, {name: 'AES-CBC'}, false, ['encrypt']).then(function(key) {
window.crypto.subtle
.importKey('raw', aes_key, { name: 'AES-CBC' }, false, ['encrypt'])
.then(function(key) {
var iv = libsignal.crypto.getRandomBytes(16);
window.crypto.subtle.encrypt({name: 'AES-CBC', iv: new Uint8Array(iv)}, key, signal).then(function(ciphertext) {
window.crypto.subtle.importKey('raw', mac_key, {name: 'HMAC', hash: {name: 'SHA-256'}}, false, ['sign']).then(function(key) {
window.crypto.subtle.sign( {name: 'HMAC', hash: 'SHA-256'}, key, signal).then(function(mac) {
window.crypto.subtle
.encrypt({ name: 'AES-CBC', iv: new Uint8Array(iv) }, key, signal)
.then(function(ciphertext) {
window.crypto.subtle
.importKey(
'raw',
mac_key,
{ name: 'HMAC', hash: { name: 'SHA-256' } },
false,
['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 ]);
var message = dcodeIO.ByteBuffer.concat([
version,
iv,
ciphertext,
mac,
]);
websocketmessage.request.body = message.toArrayBuffer();
console.log(new Uint8Array(message.toArrayBuffer()));
done();
@ -50,7 +71,11 @@ describe('MessageReceiver', function() {
});
it('connects', function(done) {
var mockServer = new MockServer('ws://localhost:8080/v1/websocket/?login='+ encodeURIComponent(number) +'.1&password=password');
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()]));
@ -65,7 +90,10 @@ describe('MessageReceiver', function() {
server.close();
done();
});
var messageReceiver = new textsecure.MessageReceiver('ws://localhost:8080', window);
var messageReceiver = new textsecure.MessageReceiver(
'ws://localhost:8080',
window
);
});
});
});

22
libtextsecure/test/protocol_test.js
View file

@ -1,30 +1,36 @@
'use strict';
describe('Protocol', function() {
describe('Unencrypted PushMessageProto "decrypt"', function() {
//exclusive
it('works', function(done) {
localStorage.clear();
var text_message = new textsecure.protobuf.DataMessage();
text_message.body = "Hi Mom";
text_message.body = 'Hi Mom';
var server_message = {
type: 4, // unencrypted
source: "+19999999999",
source: '+19999999999',
timestamp: 42,
message: text_message.encode()
message: text_message.encode(),
};
return textsecure.protocol_wrapper.handleEncryptedMessage(
return textsecure.protocol_wrapper
.handleEncryptedMessage(
server_message.source,
server_message.source_device,
server_message.type,
server_message.message
).then(function(message) {
)
.then(function(message) {
assert.equal(message.body, text_message.body);
assert.equal(message.attachments.length, text_message.attachments.length);
assert.equal(
message.attachments.length,
text_message.attachments.length
);
assert.equal(text_message.attachments.length, 0);
}).then(done).catch(done);
})
.then(done)
.catch(done);
});
});

22
libtextsecure/test/protocol_wrapper_test.js
View file

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

122
libtextsecure/test/storage_test.js
View file

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

28
libtextsecure/test/task_with_timeout_test.js
View file

@ -8,7 +8,7 @@ describe('createTaskWithTimeout', function() {
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().then(function(result) {
assert.strictEqual(result, 'hi!')
assert.strictEqual(result, 'hi!');
});
});
it('flows error from promise back', function() {
@ -34,14 +34,17 @@ describe('createTaskWithTimeout', function() {
});
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
timeout: 10
timeout: 10,
});
return taskWithTimeout().then(function() {
return taskWithTimeout().then(
function() {
throw new Error('it was not supposed to resolve!');
}, function() {
},
function() {
assert.strictEqual(complete, false);
});
}
);
});
it('resolves if task returns something falsey', function() {
var task = function() {};
@ -54,7 +57,7 @@ describe('createTaskWithTimeout', function() {
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().then(function(result) {
assert.strictEqual(result, 'hi!')
assert.strictEqual(result, 'hi!');
});
});
it('rejects if task throws (and does not log about taking too long)', function() {
@ -63,12 +66,15 @@ describe('createTaskWithTimeout', function() {
throw error;
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
timeout: 10
timeout: 10,
});
return taskWithTimeout().then(function(result) {
throw new Error('Overall task should reject!')
}, function(flowedError) {
return taskWithTimeout().then(
function(result) {
throw new Error('Overall task should reject!');
},
function(flowedError) {
assert.strictEqual(flowedError, error);
});
}
);
});
});

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

@ -1,4 +1,4 @@
;(function() {
(function() {
'use strict';
describe('WebSocket-Resource', function() {
@ -9,7 +9,10 @@
var socket = {
send: function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.RESPONSE);
assert.strictEqual(
message.type,
textsecure.protobuf.WebSocketMessage.Type.RESPONSE
);
assert.strictEqual(message.response.message, 'OK');
assert.strictEqual(message.response.status, 200);
assert.strictEqual(message.response.id.toString(), request_id);
@ -23,9 +26,12 @@
handleRequest: function(request) {
assert.strictEqual(request.verb, 'PUT');
assert.strictEqual(request.path, '/some/path');
assertEqualArrayBuffers(request.body.toArrayBuffer(), new Uint8Array([1,2,3]).buffer);
assertEqualArrayBuffers(
request.body.toArrayBuffer(),
new Uint8Array([1, 2, 3]).buffer
);
request.respond(200, 'OK');
}
},
});
// mock socket request
@ -37,10 +43,12 @@
id: request_id,
verb: 'PUT',
path: '/some/path',
body: new Uint8Array([1,2,3]).buffer
}
}).encode().toArrayBuffer()
])
body: new Uint8Array([1, 2, 3]).buffer,
},
})
.encode()
.toArrayBuffer(),
]),
});
});
@ -50,10 +58,16 @@
var socket = {
send: function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.REQUEST);
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);
assertEqualArrayBuffers(
message.request.body.toArrayBuffer(),
new Uint8Array([1, 2, 3]).buffer
);
request_id = message.request.id;
},
addEventListener: function() {},
@ -70,7 +84,7 @@
assert.strictEqual(message, 'OK');
assert.strictEqual(status, 200);
done();
}
},
});
// mock socket response
@ -78,36 +92,51 @@
data: new Blob([
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
response: { id: request_id, message: 'OK', status: 200 }
}).encode().toArrayBuffer()
])
response: { id: request_id, message: 'OK', status: 200 },
})
.encode()
.toArrayBuffer(),
]),
});
});
});
describe('close', function() {
before(function() { window.WebSocket = MockSocket; });
after (function() { window.WebSocket = WebSocket; });
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'));
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; });
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.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/v1/keepalive');
server.close();
@ -115,7 +144,7 @@
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: { path: '/v1/keepalive' }
keepalive: { path: '/v1/keepalive' },
});
});
@ -124,7 +153,10 @@
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.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/');
server.close();
@ -132,9 +164,8 @@
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: true
keepalive: true,
});
});
it('optionally disconnects if no response', function(done) {
@ -155,19 +186,25 @@
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.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');
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()
resource.resetKeepAliveTimer();
}, 5000);
});
});
});
}());
})();

10
libtextsecure/test/websocket_test.js
View file

@ -1,7 +1,11 @@
describe('TextSecureWebSocket', function() {
var RealWebSocket = window.WebSocket;
before(function() { window.WebSocket = MockSocket; });
after (function() { window.WebSocket = RealWebSocket; });
before(function() {
window.WebSocket = MockSocket;
});
after(function() {
window.WebSocket = RealWebSocket;
});
it('connects and disconnects', function(done) {
var mockServer = new MockServer('ws://localhost:8080');
mockServer.on('connection', function(server) {
@ -27,7 +31,6 @@ describe('TextSecureWebSocket', function() {
done();
};
socket.send('syn');
});
it('exposes the socket status', function(done) {
@ -58,5 +61,4 @@ describe('TextSecureWebSocket', function() {
};
mockServer.close();
});
});

71
libtextsecure/websocket-resources.js
View file

@ -1,4 +1,4 @@
;(function(){
(function() {
'use strict';
/*
@ -54,8 +54,10 @@
socket.send(
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
response: { id: request.id, message: message, status: status }
}).encode().toArrayBuffer()
response: { id: request.id, message: message, status: status },
})
.encode()
.toArrayBuffer()
);
};
};
@ -71,9 +73,11 @@
verb: request.verb,
path: request.path,
body: request.body,
id : request.id
}
}).encode().toArrayBuffer()
id: request.id,
},
})
.encode()
.toArrayBuffer()
);
};
@ -93,18 +97,21 @@
var blob = socketMessage.data;
var handleArrayBuffer = function(buffer) {
var message = textsecure.protobuf.WebSocketMessage.decode(buffer);
if (message.type === textsecure.protobuf.WebSocketMessage.Type.REQUEST ) {
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
socket: socket,
})
);
}
else if (message.type === textsecure.protobuf.WebSocketMessage.Type.RESPONSE ) {
} else if (
message.type === textsecure.protobuf.WebSocketMessage.Type.RESPONSE
) {
var response = message.response;
var request = outgoing[response.id];
if (request) {
@ -118,7 +125,8 @@
callback(response.message, response.status, request);
}
} else {
throw 'Received response for unknown request ' + message.response.id;
throw 'Received response for unknown request ' +
message.response.id;
}
}
};
@ -137,17 +145,23 @@
if (opts.keepalive) {
this.keepalive = new KeepAlive(this, {
path: opts.keepalive.path,
disconnect : opts.keepalive.disconnect
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',
this.keepalive.stop.bind(this.keepalive)
);
}
socket.addEventListener('close', function() {
socket.addEventListener(
'close',
function() {
this.closed = true;
}.bind(this))
}.bind(this)
);
this.close = function(code, reason) {
if (this.closed) {
@ -168,7 +182,8 @@
// 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() {
setTimeout(
function() {
if (this.closed) {
return;
}
@ -179,12 +194,13 @@
ev.code = code;
ev.reason = reason;
this.dispatchEvent(ev);
}.bind(this), 1000);
}.bind(this),
1000
);
};
};
window.WebSocketResource.prototype = new textsecure.EventTarget();
function KeepAlive(websocketResource, opts) {
if (websocketResource instanceof WebSocketResource) {
opts = opts || {};
@ -211,13 +227,17 @@
reset: function() {
clearTimeout(this.keepAliveTimer);
clearTimeout(this.disconnectTimer);
this.keepAliveTimer = setTimeout(function() {
this.keepAliveTimer = setTimeout(
function() {
if (this.disconnect) {
// automatically disconnect if server doesn't ack
this.disconnectTimer = setTimeout(function() {
this.disconnectTimer = setTimeout(
function() {
clearTimeout(this.keepAliveTimer);
this.wsr.close(3001, 'No response to keepalive request');
}.bind(this), 1000);
}.bind(this),
1000
);
} else {
this.reset();
}
@ -225,10 +245,11 @@
this.wsr.sendRequest({
verb: 'GET',
path: this.path,
success: this.reset.bind(this)
success: this.reset.bind(this),
});
}.bind(this), 55000);
}.bind(this),
55000
);
},
};
}());
})();