1030 lines
34 KiB
JavaScript
1030 lines
34 KiB
JavaScript
(function() {
|
|
'use strict';
|
|
var TIMESTAMP_THRESHOLD = 5 * 1000; // 5 seconds
|
|
var Direction = {
|
|
SENDING: 1,
|
|
RECEIVING: 2,
|
|
};
|
|
|
|
var VerifiedStatus = {
|
|
DEFAULT: 0,
|
|
VERIFIED: 1,
|
|
UNVERIFIED: 2,
|
|
};
|
|
|
|
function validateVerifiedStatus(status) {
|
|
if (
|
|
status === VerifiedStatus.DEFAULT ||
|
|
status === VerifiedStatus.VERIFIED ||
|
|
status === VerifiedStatus.UNVERIFIED
|
|
) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
var StaticByteBufferProto = new dcodeIO.ByteBuffer().__proto__;
|
|
var StaticArrayBufferProto = new ArrayBuffer().__proto__;
|
|
var StaticUint8ArrayProto = new Uint8Array().__proto__;
|
|
|
|
function isStringable(thing) {
|
|
return (
|
|
thing === Object(thing) &&
|
|
(thing.__proto__ == StaticArrayBufferProto ||
|
|
thing.__proto__ == StaticUint8ArrayProto ||
|
|
thing.__proto__ == StaticByteBufferProto)
|
|
);
|
|
}
|
|
function convertToArrayBuffer(thing) {
|
|
if (thing === undefined) {
|
|
return undefined;
|
|
}
|
|
if (thing === Object(thing)) {
|
|
if (thing.__proto__ == StaticArrayBufferProto) {
|
|
return thing;
|
|
}
|
|
//TODO: Several more cases here...
|
|
}
|
|
|
|
if (thing instanceof Array) {
|
|
// Assuming Uint16Array from curve25519
|
|
var res = new ArrayBuffer(thing.length * 2);
|
|
var uint = new Uint16Array(res);
|
|
for (var i = 0; i < thing.length; i++) {
|
|
uint[i] = thing[i];
|
|
}
|
|
return res;
|
|
}
|
|
|
|
var str;
|
|
if (isStringable(thing)) {
|
|
str = stringObject(thing);
|
|
} else if (typeof thing == 'string') {
|
|
str = thing;
|
|
} else {
|
|
throw new Error(
|
|
'Tried to convert a non-stringable thing of type ' +
|
|
typeof thing +
|
|
' to an array buffer'
|
|
);
|
|
}
|
|
var res = new ArrayBuffer(str.length);
|
|
var uint = new Uint8Array(res);
|
|
for (var i = 0; i < str.length; i++) {
|
|
uint[i] = str.charCodeAt(i);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function equalArrayBuffers(ab1, ab2) {
|
|
if (!(ab1 instanceof ArrayBuffer && ab2 instanceof ArrayBuffer)) {
|
|
return false;
|
|
}
|
|
if (ab1.byteLength !== ab2.byteLength) {
|
|
return false;
|
|
}
|
|
var result = 0;
|
|
var ta1 = new Uint8Array(ab1);
|
|
var ta2 = new Uint8Array(ab2);
|
|
for (var i = 0; i < ab1.byteLength; ++i) {
|
|
result = result | (ta1[i] ^ ta2[i]);
|
|
}
|
|
return result === 0;
|
|
}
|
|
|
|
var Model = Backbone.Model.extend({ database: Whisper.Database });
|
|
var PreKey = Model.extend({ storeName: 'preKeys' });
|
|
var PreKeyCollection = Backbone.Collection.extend({
|
|
storeName: 'preKeys',
|
|
database: Whisper.Database,
|
|
model: PreKey,
|
|
});
|
|
var SignedPreKey = Model.extend({ storeName: 'signedPreKeys' });
|
|
var SignedPreKeyCollection = Backbone.Collection.extend({
|
|
storeName: 'signedPreKeys',
|
|
database: Whisper.Database,
|
|
model: SignedPreKey,
|
|
});
|
|
var Session = Model.extend({ storeName: 'sessions' });
|
|
var SessionCollection = Backbone.Collection.extend({
|
|
storeName: 'sessions',
|
|
database: Whisper.Database,
|
|
model: Session,
|
|
fetchSessionsForNumber: function(number) {
|
|
return this.fetch({ range: [number + '.1', number + '.' + ':'] });
|
|
},
|
|
});
|
|
var Unprocessed = Model.extend({ storeName: 'unprocessed' });
|
|
var UnprocessedCollection = Backbone.Collection.extend({
|
|
storeName: 'unprocessed',
|
|
database: Whisper.Database,
|
|
model: Unprocessed,
|
|
comparator: 'timestamp',
|
|
});
|
|
var IdentityRecord = Model.extend({
|
|
storeName: 'identityKeys',
|
|
validAttributes: [
|
|
'id',
|
|
'publicKey',
|
|
'firstUse',
|
|
'timestamp',
|
|
'verified',
|
|
'nonblockingApproval',
|
|
],
|
|
validate: function(attrs, options) {
|
|
var attributeNames = _.keys(attrs);
|
|
var validAttributes = this.validAttributes;
|
|
var allValid = _.all(attributeNames, function(attributeName) {
|
|
return _.contains(validAttributes, attributeName);
|
|
});
|
|
if (!allValid) {
|
|
return new Error('Invalid identity key attribute names');
|
|
}
|
|
var allPresent = _.all(validAttributes, function(attributeName) {
|
|
return _.contains(attributeNames, attributeName);
|
|
});
|
|
if (!allPresent) {
|
|
return new Error('Missing identity key attributes');
|
|
}
|
|
|
|
if (typeof attrs.id !== 'string') {
|
|
return new Error('Invalid identity key id');
|
|
}
|
|
if (!(attrs.publicKey instanceof ArrayBuffer)) {
|
|
return new Error('Invalid identity key publicKey');
|
|
}
|
|
if (typeof attrs.firstUse !== 'boolean') {
|
|
return new Error('Invalid identity key firstUse');
|
|
}
|
|
if (typeof attrs.timestamp !== 'number' || !(attrs.timestamp >= 0)) {
|
|
return new Error('Invalid identity key timestamp');
|
|
}
|
|
if (!validateVerifiedStatus(attrs.verified)) {
|
|
return new Error('Invalid identity key verified');
|
|
}
|
|
if (typeof attrs.nonblockingApproval !== 'boolean') {
|
|
return new Error('Invalid identity key nonblockingApproval');
|
|
}
|
|
},
|
|
});
|
|
var Group = Model.extend({ storeName: 'groups' });
|
|
var Item = Model.extend({ storeName: 'items' });
|
|
|
|
function SignalProtocolStore() {}
|
|
|
|
SignalProtocolStore.prototype = {
|
|
constructor: SignalProtocolStore,
|
|
getIdentityKeyPair: function() {
|
|
var item = new Item({ id: 'identityKey' });
|
|
return new Promise(function(resolve, reject) {
|
|
item.fetch().then(function() {
|
|
resolve(item.get('value'));
|
|
}, reject);
|
|
});
|
|
},
|
|
getLocalRegistrationId: function() {
|
|
var item = new Item({ id: 'registrationId' });
|
|
return new Promise(function(resolve, reject) {
|
|
item.fetch().then(function() {
|
|
resolve(item.get('value'));
|
|
}, reject);
|
|
});
|
|
},
|
|
|
|
/* Returns a prekeypair object or undefined */
|
|
loadPreKey: function(keyId) {
|
|
var prekey = new PreKey({ id: keyId });
|
|
return new Promise(function(resolve) {
|
|
prekey.fetch().then(
|
|
function() {
|
|
console.log('Successfully fetched prekey:', keyId);
|
|
resolve({
|
|
pubKey: prekey.get('publicKey'),
|
|
privKey: prekey.get('privateKey'),
|
|
});
|
|
},
|
|
function() {
|
|
console.log('Failed to fetch prekey:', keyId);
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
},
|
|
storePreKey: function(keyId, keyPair) {
|
|
var prekey = new PreKey({
|
|
id: keyId,
|
|
publicKey: keyPair.pubKey,
|
|
privateKey: keyPair.privKey,
|
|
});
|
|
return new Promise(function(resolve) {
|
|
prekey.save().always(function() {
|
|
resolve();
|
|
});
|
|
});
|
|
},
|
|
removePreKey: function(keyId) {
|
|
var prekey = new PreKey({ id: keyId });
|
|
|
|
this.trigger('removePreKey');
|
|
|
|
return new Promise(function(resolve) {
|
|
var deferred = prekey.destroy();
|
|
if (!deferred) {
|
|
return resolve();
|
|
}
|
|
|
|
return deferred.then(resolve, function(error) {
|
|
console.log(
|
|
'removePreKey error:',
|
|
error && error.stack ? error.stack : error
|
|
);
|
|
resolve();
|
|
});
|
|
});
|
|
},
|
|
clearPreKeyStore: function() {
|
|
return new Promise(function(resolve) {
|
|
var preKeys = new PreKeyCollection();
|
|
preKeys.sync('delete', preKeys, {}).always(resolve);
|
|
});
|
|
},
|
|
|
|
/* Returns a signed keypair object or undefined */
|
|
loadSignedPreKey: function(keyId) {
|
|
var prekey = new SignedPreKey({ id: keyId });
|
|
return new Promise(function(resolve) {
|
|
prekey
|
|
.fetch()
|
|
.then(function() {
|
|
console.log(
|
|
'Successfully fetched signed prekey:',
|
|
prekey.get('id')
|
|
);
|
|
resolve({
|
|
pubKey: prekey.get('publicKey'),
|
|
privKey: prekey.get('privateKey'),
|
|
created_at: prekey.get('created_at'),
|
|
keyId: prekey.get('id'),
|
|
confirmed: prekey.get('confirmed'),
|
|
});
|
|
})
|
|
.fail(function() {
|
|
console.log('Failed to fetch signed prekey:', keyId);
|
|
resolve();
|
|
});
|
|
});
|
|
},
|
|
loadSignedPreKeys: function() {
|
|
if (arguments.length > 0) {
|
|
return Promise.reject(
|
|
new Error('loadSignedPreKeys takes no arguments')
|
|
);
|
|
}
|
|
var signedPreKeys = new SignedPreKeyCollection();
|
|
return new Promise(function(resolve) {
|
|
signedPreKeys.fetch().then(function() {
|
|
resolve(
|
|
signedPreKeys.map(function(prekey) {
|
|
return {
|
|
pubKey: prekey.get('publicKey'),
|
|
privKey: prekey.get('privateKey'),
|
|
created_at: prekey.get('created_at'),
|
|
keyId: prekey.get('id'),
|
|
confirmed: prekey.get('confirmed'),
|
|
};
|
|
})
|
|
);
|
|
});
|
|
});
|
|
},
|
|
storeSignedPreKey: function(keyId, keyPair, confirmed) {
|
|
var prekey = new SignedPreKey({
|
|
id: keyId,
|
|
publicKey: keyPair.pubKey,
|
|
privateKey: keyPair.privKey,
|
|
created_at: Date.now(),
|
|
confirmed: Boolean(confirmed),
|
|
});
|
|
return new Promise(function(resolve) {
|
|
prekey.save().always(function() {
|
|
resolve();
|
|
});
|
|
});
|
|
},
|
|
removeSignedPreKey: function(keyId) {
|
|
var prekey = new SignedPreKey({ id: keyId });
|
|
return new Promise(function(resolve, reject) {
|
|
var deferred = prekey.destroy();
|
|
if (!deferred) {
|
|
return resolve();
|
|
}
|
|
|
|
deferred.then(resolve, reject);
|
|
});
|
|
},
|
|
clearSignedPreKeysStore: function() {
|
|
return new Promise(function(resolve) {
|
|
var signedPreKeys = new SignedPreKeyCollection();
|
|
signedPreKeys.sync('delete', signedPreKeys, {}).always(resolve);
|
|
});
|
|
},
|
|
|
|
loadSession: function(encodedNumber) {
|
|
if (encodedNumber === null || encodedNumber === undefined) {
|
|
throw new Error('Tried to get session for undefined/null number');
|
|
}
|
|
return new Promise(function(resolve) {
|
|
var session = new Session({ id: encodedNumber });
|
|
session.fetch().always(function() {
|
|
resolve(session.get('record'));
|
|
});
|
|
});
|
|
},
|
|
storeSession: function(encodedNumber, record) {
|
|
if (encodedNumber === null || encodedNumber === undefined) {
|
|
throw new Error('Tried to put session for undefined/null number');
|
|
}
|
|
return new Promise(function(resolve) {
|
|
var number = textsecure.utils.unencodeNumber(encodedNumber)[0];
|
|
var deviceId = parseInt(
|
|
textsecure.utils.unencodeNumber(encodedNumber)[1]
|
|
);
|
|
|
|
var session = new Session({ id: encodedNumber });
|
|
session.fetch().always(function() {
|
|
session
|
|
.save({
|
|
record: record,
|
|
deviceId: deviceId,
|
|
number: number,
|
|
})
|
|
.fail(function(e) {
|
|
console.log('Failed to save session', encodedNumber, e);
|
|
})
|
|
.always(function() {
|
|
resolve();
|
|
});
|
|
});
|
|
});
|
|
},
|
|
getDeviceIds: function(number) {
|
|
if (number === null || number === undefined) {
|
|
throw new Error('Tried to get device ids for undefined/null number');
|
|
}
|
|
return new Promise(function(resolve) {
|
|
var sessions = new SessionCollection();
|
|
sessions.fetchSessionsForNumber(number).always(function() {
|
|
resolve(sessions.pluck('deviceId'));
|
|
});
|
|
});
|
|
},
|
|
removeSession: function(encodedNumber) {
|
|
console.log('deleting session for ', encodedNumber);
|
|
return new Promise(function(resolve) {
|
|
var session = new Session({ id: encodedNumber });
|
|
session
|
|
.fetch()
|
|
.then(function() {
|
|
session.destroy().then(resolve);
|
|
})
|
|
.fail(resolve);
|
|
});
|
|
},
|
|
removeAllSessions: function(number) {
|
|
if (number === null || number === undefined) {
|
|
throw new Error('Tried to remove sessions for undefined/null number');
|
|
}
|
|
return new Promise(function(resolve, reject) {
|
|
var sessions = new SessionCollection();
|
|
sessions.fetchSessionsForNumber(number).always(function() {
|
|
var promises = [];
|
|
while (sessions.length > 0) {
|
|
promises.push(
|
|
new Promise(function(res, rej) {
|
|
sessions
|
|
.pop()
|
|
.destroy()
|
|
.then(res, rej);
|
|
})
|
|
);
|
|
}
|
|
Promise.all(promises).then(resolve, reject);
|
|
});
|
|
});
|
|
},
|
|
archiveSiblingSessions: function(identifier) {
|
|
var address = libsignal.SignalProtocolAddress.fromString(identifier);
|
|
return this.getDeviceIds(address.getName()).then(function(deviceIds) {
|
|
var deviceIds = _.without(deviceIds, address.getDeviceId());
|
|
return Promise.all(
|
|
deviceIds.map(function(deviceId) {
|
|
var sibling = new libsignal.SignalProtocolAddress(
|
|
address.getName(),
|
|
deviceId
|
|
);
|
|
console.log('closing session for', sibling.toString());
|
|
var sessionCipher = new libsignal.SessionCipher(
|
|
textsecure.storage.protocol,
|
|
sibling
|
|
);
|
|
return sessionCipher.closeOpenSessionForDevice();
|
|
})
|
|
);
|
|
});
|
|
},
|
|
archiveAllSessions: function(number) {
|
|
return this.getDeviceIds(number).then(function(deviceIds) {
|
|
return Promise.all(
|
|
deviceIds.map(function(deviceId) {
|
|
var address = new libsignal.SignalProtocolAddress(number, deviceId);
|
|
console.log('closing session for', address.toString());
|
|
var sessionCipher = new libsignal.SessionCipher(
|
|
textsecure.storage.protocol,
|
|
address
|
|
);
|
|
return sessionCipher.closeOpenSessionForDevice();
|
|
})
|
|
);
|
|
});
|
|
},
|
|
clearSessionStore: function() {
|
|
return new Promise(function(resolve) {
|
|
var sessions = new SessionCollection();
|
|
sessions.sync('delete', sessions, {}).always(resolve);
|
|
});
|
|
},
|
|
isTrustedIdentity: function(identifier, publicKey, direction) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to get identity key for undefined/null key');
|
|
}
|
|
var number = textsecure.utils.unencodeNumber(identifier)[0];
|
|
var isOurNumber = number === textsecure.storage.user.getNumber();
|
|
var identityRecord = new IdentityRecord({ id: number });
|
|
return new Promise(function(resolve) {
|
|
identityRecord.fetch().always(resolve);
|
|
}).then(
|
|
function() {
|
|
var existing = identityRecord.get('publicKey');
|
|
|
|
if (isOurNumber) {
|
|
return equalArrayBuffers(existing, publicKey);
|
|
}
|
|
|
|
switch (direction) {
|
|
case Direction.SENDING:
|
|
return this.isTrustedForSending(publicKey, identityRecord);
|
|
case Direction.RECEIVING:
|
|
return true;
|
|
default:
|
|
throw new Error('Unknown direction: ' + direction);
|
|
}
|
|
}.bind(this)
|
|
);
|
|
},
|
|
isTrustedForSending: function(publicKey, identityRecord) {
|
|
var existing = identityRecord.get('publicKey');
|
|
|
|
if (!existing) {
|
|
console.log('isTrustedForSending: Nothing here, returning true...');
|
|
return true;
|
|
}
|
|
if (!equalArrayBuffers(existing, publicKey)) {
|
|
console.log("isTrustedForSending: Identity keys don't match...");
|
|
return false;
|
|
}
|
|
if (identityRecord.get('verified') === VerifiedStatus.UNVERIFIED) {
|
|
console.log('Needs unverified approval!');
|
|
return false;
|
|
}
|
|
if (this.isNonBlockingApprovalRequired(identityRecord)) {
|
|
console.log('isTrustedForSending: Needs non-blocking approval!');
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
loadIdentityKey: function(identifier) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to get identity key for undefined/null key');
|
|
}
|
|
var number = textsecure.utils.unencodeNumber(identifier)[0];
|
|
return new Promise(function(resolve) {
|
|
var identityRecord = new IdentityRecord({ id: number });
|
|
identityRecord.fetch().always(function() {
|
|
resolve(identityRecord.get('publicKey'));
|
|
});
|
|
});
|
|
},
|
|
saveIdentity: function(identifier, publicKey, nonblockingApproval) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to put identity key for undefined/null key');
|
|
}
|
|
if (!(publicKey instanceof ArrayBuffer)) {
|
|
publicKey = convertToArrayBuffer(publicKey);
|
|
}
|
|
if (typeof nonblockingApproval !== 'boolean') {
|
|
nonblockingApproval = false;
|
|
}
|
|
var number = textsecure.utils.unencodeNumber(identifier)[0];
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: number });
|
|
identityRecord.fetch().always(
|
|
function() {
|
|
var oldpublicKey = identityRecord.get('publicKey');
|
|
if (!oldpublicKey) {
|
|
// Lookup failed, or the current key was removed, so save this one.
|
|
console.log('Saving new identity...');
|
|
identityRecord
|
|
.save({
|
|
publicKey: publicKey,
|
|
firstUse: true,
|
|
timestamp: Date.now(),
|
|
verified: VerifiedStatus.DEFAULT,
|
|
nonblockingApproval: nonblockingApproval,
|
|
})
|
|
.then(function() {
|
|
resolve(false);
|
|
}, reject);
|
|
} else if (!equalArrayBuffers(oldpublicKey, publicKey)) {
|
|
console.log('Replacing existing identity...');
|
|
var previousStatus = identityRecord.get('verified');
|
|
var verifiedStatus;
|
|
if (
|
|
previousStatus === VerifiedStatus.VERIFIED ||
|
|
previousStatus === VerifiedStatus.UNVERIFIED
|
|
) {
|
|
verifiedStatus = VerifiedStatus.UNVERIFIED;
|
|
} else {
|
|
verifiedStatus = VerifiedStatus.DEFAULT;
|
|
}
|
|
identityRecord
|
|
.save({
|
|
publicKey: publicKey,
|
|
firstUse: false,
|
|
timestamp: Date.now(),
|
|
verified: verifiedStatus,
|
|
nonblockingApproval: nonblockingApproval,
|
|
})
|
|
.then(
|
|
function() {
|
|
this.trigger('keychange', number);
|
|
this.archiveSiblingSessions(identifier).then(function() {
|
|
resolve(true);
|
|
}, reject);
|
|
}.bind(this),
|
|
reject
|
|
);
|
|
} else if (this.isNonBlockingApprovalRequired(identityRecord)) {
|
|
console.log('Setting approval status...');
|
|
identityRecord
|
|
.save({
|
|
nonblockingApproval: nonblockingApproval,
|
|
})
|
|
.then(function() {
|
|
resolve(false);
|
|
}, reject);
|
|
} else {
|
|
resolve(false);
|
|
}
|
|
}.bind(this)
|
|
);
|
|
}.bind(this)
|
|
);
|
|
},
|
|
isNonBlockingApprovalRequired: function(identityRecord) {
|
|
return (
|
|
!identityRecord.get('firstUse') &&
|
|
Date.now() - identityRecord.get('timestamp') < TIMESTAMP_THRESHOLD &&
|
|
!identityRecord.get('nonblockingApproval')
|
|
);
|
|
},
|
|
saveIdentityWithAttributes: function(identifier, attributes) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to put identity key for undefined/null key');
|
|
}
|
|
var number = textsecure.utils.unencodeNumber(identifier)[0];
|
|
return new Promise(function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: number });
|
|
identityRecord.set(attributes);
|
|
if (identityRecord.isValid()) {
|
|
// false if invalid attributes
|
|
identityRecord.save().then(resolve);
|
|
} else {
|
|
reject(identityRecord.validationError);
|
|
}
|
|
});
|
|
},
|
|
setApproval: function(identifier, nonblockingApproval) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set approval for undefined/null identifier');
|
|
}
|
|
if (typeof nonblockingApproval !== 'boolean') {
|
|
throw new Error('Invalid approval status');
|
|
}
|
|
var number = textsecure.utils.unencodeNumber(identifier)[0];
|
|
return new Promise(function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: number });
|
|
identityRecord.fetch().then(function() {
|
|
identityRecord
|
|
.save({
|
|
nonblockingApproval: nonblockingApproval,
|
|
})
|
|
.then(
|
|
function() {
|
|
resolve();
|
|
},
|
|
function() {
|
|
// catch
|
|
reject(new Error('No identity record for ' + number));
|
|
}
|
|
);
|
|
});
|
|
});
|
|
},
|
|
setVerified: function(identifier, verifiedStatus, publicKey) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set verified for undefined/null key');
|
|
}
|
|
if (!validateVerifiedStatus(verifiedStatus)) {
|
|
throw new Error('Invalid verified status');
|
|
}
|
|
if (arguments.length > 2 && !(publicKey instanceof ArrayBuffer)) {
|
|
throw new Error('Invalid public key');
|
|
}
|
|
return new Promise(function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: identifier });
|
|
identityRecord.fetch().then(
|
|
function() {
|
|
if (
|
|
!publicKey ||
|
|
equalArrayBuffers(identityRecord.get('publicKey'), publicKey)
|
|
) {
|
|
identityRecord.set({ verified: verifiedStatus });
|
|
|
|
if (identityRecord.isValid()) {
|
|
identityRecord.save({}).then(function() {
|
|
resolve();
|
|
}, reject);
|
|
} else {
|
|
reject(identityRecord.validationError);
|
|
}
|
|
} else {
|
|
console.log('No identity record for specified publicKey');
|
|
resolve();
|
|
}
|
|
},
|
|
function() {
|
|
// catch
|
|
reject(new Error('No identity record for ' + identifier));
|
|
}
|
|
);
|
|
});
|
|
},
|
|
getVerified: function(identifier) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set verified for undefined/null key');
|
|
}
|
|
return new Promise(function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: identifier });
|
|
identityRecord.fetch().then(
|
|
function() {
|
|
var verifiedStatus = identityRecord.get('verified');
|
|
if (validateVerifiedStatus(verifiedStatus)) {
|
|
resolve(verifiedStatus);
|
|
} else {
|
|
resolve(VerifiedStatus.DEFAULT);
|
|
}
|
|
},
|
|
function() {
|
|
// catch
|
|
reject(new Error('No identity record for ' + identifier));
|
|
}
|
|
);
|
|
});
|
|
},
|
|
// Resolves to true if a new identity key was saved
|
|
processContactSyncVerificationState: function(
|
|
identifier,
|
|
verifiedStatus,
|
|
publicKey
|
|
) {
|
|
if (verifiedStatus === VerifiedStatus.UNVERIFIED) {
|
|
return this.processUnverifiedMessage(
|
|
identifier,
|
|
verifiedStatus,
|
|
publicKey
|
|
);
|
|
} else {
|
|
return this.processVerifiedMessage(
|
|
identifier,
|
|
verifiedStatus,
|
|
publicKey
|
|
);
|
|
}
|
|
},
|
|
// This function encapsulates the non-Java behavior, since the mobile apps don't
|
|
// currently receive contact syncs and therefore will see a verify sync with
|
|
// UNVERIFIED status
|
|
processUnverifiedMessage: function(identifier, verifiedStatus, publicKey) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set verified for undefined/null key');
|
|
}
|
|
if (publicKey !== undefined && !(publicKey instanceof ArrayBuffer)) {
|
|
throw new Error('Invalid public key');
|
|
}
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: identifier });
|
|
var isPresent = false;
|
|
var isEqual = false;
|
|
identityRecord
|
|
.fetch()
|
|
.then(function() {
|
|
isPresent = true;
|
|
if (publicKey) {
|
|
isEqual = equalArrayBuffers(
|
|
publicKey,
|
|
identityRecord.get('publicKey')
|
|
);
|
|
}
|
|
})
|
|
.always(
|
|
function() {
|
|
if (
|
|
isPresent &&
|
|
isEqual &&
|
|
identityRecord.get('verified') !== VerifiedStatus.UNVERIFIED
|
|
) {
|
|
return textsecure.storage.protocol
|
|
.setVerified(identifier, verifiedStatus, publicKey)
|
|
.then(resolve, reject);
|
|
}
|
|
|
|
if (!isPresent || !isEqual) {
|
|
return textsecure.storage.protocol
|
|
.saveIdentityWithAttributes(identifier, {
|
|
publicKey: publicKey,
|
|
verified: verifiedStatus,
|
|
firstUse: false,
|
|
timestamp: Date.now(),
|
|
nonblockingApproval: true,
|
|
})
|
|
.then(
|
|
function() {
|
|
if (isPresent && !isEqual) {
|
|
this.trigger('keychange', identifier);
|
|
return this.archiveAllSessions(identifier).then(
|
|
function() {
|
|
// true signifies that we overwrote a previous key with a new one
|
|
return resolve(true);
|
|
},
|
|
reject
|
|
);
|
|
}
|
|
|
|
return resolve();
|
|
}.bind(this),
|
|
reject
|
|
);
|
|
}
|
|
|
|
// The situation which could get us here is:
|
|
// 1. had a previous key
|
|
// 2. new key is the same
|
|
// 3. desired new status is same as what we had before
|
|
return resolve();
|
|
}.bind(this)
|
|
);
|
|
}.bind(this)
|
|
);
|
|
},
|
|
// This matches the Java method as of
|
|
// https://github.com/signalapp/Signal-Android/blob/d0bb68e1378f689e4d10ac6a46014164992ca4e4/src/org/thoughtcrime/securesms/util/IdentityUtil.java#L188
|
|
processVerifiedMessage: function(identifier, verifiedStatus, publicKey) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set verified for undefined/null key');
|
|
}
|
|
if (!validateVerifiedStatus(verifiedStatus)) {
|
|
throw new Error('Invalid verified status');
|
|
}
|
|
if (publicKey !== undefined && !(publicKey instanceof ArrayBuffer)) {
|
|
throw new Error('Invalid public key');
|
|
}
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: identifier });
|
|
var isPresent = false;
|
|
var isEqual = false;
|
|
identityRecord
|
|
.fetch()
|
|
.then(function() {
|
|
isPresent = true;
|
|
if (publicKey) {
|
|
isEqual = equalArrayBuffers(
|
|
publicKey,
|
|
identityRecord.get('publicKey')
|
|
);
|
|
}
|
|
})
|
|
.always(
|
|
function() {
|
|
if (!isPresent && verifiedStatus === VerifiedStatus.DEFAULT) {
|
|
console.log('No existing record for default status');
|
|
return resolve();
|
|
}
|
|
|
|
if (
|
|
isPresent &&
|
|
isEqual &&
|
|
identityRecord.get('verified') !== VerifiedStatus.DEFAULT &&
|
|
verifiedStatus === VerifiedStatus.DEFAULT
|
|
) {
|
|
return textsecure.storage.protocol
|
|
.setVerified(identifier, verifiedStatus, publicKey)
|
|
.then(resolve, reject);
|
|
}
|
|
|
|
if (
|
|
verifiedStatus === VerifiedStatus.VERIFIED &&
|
|
(!isPresent ||
|
|
(isPresent && !isEqual) ||
|
|
(isPresent &&
|
|
identityRecord.get('verified') !==
|
|
VerifiedStatus.VERIFIED))
|
|
) {
|
|
return textsecure.storage.protocol
|
|
.saveIdentityWithAttributes(identifier, {
|
|
publicKey: publicKey,
|
|
verified: verifiedStatus,
|
|
firstUse: false,
|
|
timestamp: Date.now(),
|
|
nonblockingApproval: true,
|
|
})
|
|
.then(
|
|
function() {
|
|
if (isPresent && !isEqual) {
|
|
this.trigger('keychange', identifier);
|
|
return this.archiveAllSessions(identifier).then(
|
|
function() {
|
|
// true signifies that we overwrote a previous key with a new one
|
|
return resolve(true);
|
|
},
|
|
reject
|
|
);
|
|
}
|
|
|
|
return resolve();
|
|
}.bind(this),
|
|
reject
|
|
);
|
|
}
|
|
|
|
// We get here if we got a new key and the status is DEFAULT. If the
|
|
// message is out of date, we don't want to lose whatever more-secure
|
|
// state we had before.
|
|
return resolve();
|
|
}.bind(this)
|
|
);
|
|
}.bind(this)
|
|
);
|
|
},
|
|
isUntrusted: function(identifier) {
|
|
if (identifier === null || identifier === undefined) {
|
|
throw new Error('Tried to set verified for undefined/null key');
|
|
}
|
|
return new Promise(function(resolve, reject) {
|
|
var identityRecord = new IdentityRecord({ id: identifier });
|
|
identityRecord.fetch().then(
|
|
function() {
|
|
if (
|
|
Date.now() - identityRecord.get('timestamp') <
|
|
TIMESTAMP_THRESHOLD &&
|
|
!identityRecord.get('nonblockingApproval') &&
|
|
!identityRecord.get('firstUse')
|
|
) {
|
|
resolve(true);
|
|
} else {
|
|
resolve(false);
|
|
}
|
|
},
|
|
function() {
|
|
// catch
|
|
reject(new Error('No identity record for ' + identifier));
|
|
}
|
|
);
|
|
});
|
|
},
|
|
removeIdentityKey: async function(number) {
|
|
const identityRecord = new IdentityRecord({ id: number });
|
|
try {
|
|
await wrapDeferred(identityRecord.fetch());
|
|
await wrapDeferred(identityRecord.destroy());
|
|
return textsecure.storage.protocol.removeAllSessions(number);
|
|
} catch (error) {
|
|
throw new Error('Tried to remove identity for unknown number');
|
|
}
|
|
},
|
|
|
|
// Groups
|
|
getGroup: function(groupId) {
|
|
if (groupId === null || groupId === undefined) {
|
|
throw new Error('Tried to get group for undefined/null id');
|
|
}
|
|
return new Promise(function(resolve) {
|
|
var group = new Group({ id: groupId });
|
|
group.fetch().always(function() {
|
|
resolve(group.get('data'));
|
|
});
|
|
});
|
|
},
|
|
putGroup: function(groupId, group) {
|
|
if (groupId === null || groupId === undefined) {
|
|
throw new Error('Tried to put group key for undefined/null id');
|
|
}
|
|
if (group === null || group === undefined) {
|
|
throw new Error('Tried to put undefined/null group object');
|
|
}
|
|
var group = new Group({ id: groupId, data: group });
|
|
return new Promise(function(resolve) {
|
|
group.save().always(resolve);
|
|
});
|
|
},
|
|
removeGroup: function(groupId) {
|
|
if (groupId === null || groupId === undefined) {
|
|
throw new Error('Tried to remove group key for undefined/null id');
|
|
}
|
|
return new Promise(function(resolve) {
|
|
var group = new Group({ id: groupId });
|
|
group.destroy().always(resolve);
|
|
});
|
|
},
|
|
|
|
// Not yet processed messages - for resiliency
|
|
getAllUnprocessed: function() {
|
|
var collection;
|
|
return new Promise(function(resolve, reject) {
|
|
collection = new UnprocessedCollection();
|
|
return collection.fetch().then(resolve, reject);
|
|
}).then(function() {
|
|
// Return a plain array of plain objects
|
|
return collection.map(model => model.attributes);
|
|
});
|
|
},
|
|
addUnprocessed: function(data) {
|
|
return new Promise(function(resolve, reject) {
|
|
var unprocessed = new Unprocessed(data);
|
|
return unprocessed.save().then(resolve, reject);
|
|
});
|
|
},
|
|
updateUnprocessed: function(id, updates) {
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var unprocessed = new Unprocessed({
|
|
id: id,
|
|
});
|
|
return unprocessed.fetch().then(function() {
|
|
return unprocessed.save(updates).then(resolve, reject);
|
|
}, reject);
|
|
}.bind(this)
|
|
);
|
|
},
|
|
removeUnprocessed: function(id) {
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var unprocessed = new Unprocessed({
|
|
id: id,
|
|
});
|
|
return unprocessed.destroy().then(resolve, reject);
|
|
}.bind(this)
|
|
);
|
|
},
|
|
removeAllData: function() {
|
|
// First the in-memory caches:
|
|
window.storage.reset(); // items store
|
|
ConversationController.reset(); // conversations store
|
|
|
|
// Then, the entire database:
|
|
return Whisper.Database.clear();
|
|
},
|
|
removeAllConfiguration: function() {
|
|
// First the in-memory cache for the items store:
|
|
window.storage.reset();
|
|
|
|
// Then anything in the database that isn't a message/conversation/group:
|
|
return Whisper.Database.clearStores([
|
|
'items',
|
|
'identityKeys',
|
|
'sessions',
|
|
'signedPreKeys',
|
|
'preKeys',
|
|
'unprocessed',
|
|
]);
|
|
},
|
|
};
|
|
_.extend(SignalProtocolStore.prototype, Backbone.Events);
|
|
|
|
window.SignalProtocolStore = SignalProtocolStore;
|
|
window.SignalProtocolStore.prototype.Direction = Direction;
|
|
window.SignalProtocolStore.prototype.VerifiedStatus = VerifiedStatus;
|
|
})();
|