fix SessionProtocol decrypt of messages with Android
also disable the old SessionRequest logicpull/1404/head
Audric Ackermann
4 years ago
parent
b0a229bf13
commit
2af4938ff2
@ -1,36 +0,0 @@
|
||||
import { expect } from 'chai';
|
||||
import { beforeEach } from 'mocha';
|
||||
|
||||
import { SessionEstablishedMessage } from '../../../../session/messages/outgoing';
|
||||
import { SignalService } from '../../../../protobuf';
|
||||
import { Constants } from '../../../../session';
|
||||
|
||||
describe('SessionEstablishedMessage', () => {
|
||||
let message: SessionEstablishedMessage;
|
||||
beforeEach(() => {
|
||||
const timestamp = Date.now();
|
||||
message = new SessionEstablishedMessage({ timestamp });
|
||||
});
|
||||
|
||||
it('has a nullMessage not null', () => {
|
||||
const plainText = message.plainTextBuffer();
|
||||
const decoded = SignalService.Content.decode(plainText);
|
||||
|
||||
expect(decoded.nullMessage).to.be.not.equal(
|
||||
null,
|
||||
'decoded.dataMessage.nullMessage should not be null'
|
||||
);
|
||||
});
|
||||
|
||||
it('correct ttl', () => {
|
||||
expect(message.ttl()).to.equal(Constants.TTL_DEFAULT.SESSION_ESTABLISHED);
|
||||
});
|
||||
|
||||
it('has an identifier', () => {
|
||||
expect(message.identifier).to.not.equal(null, 'identifier cannot be null');
|
||||
expect(message.identifier).to.not.equal(
|
||||
undefined,
|
||||
'identifier cannot be undefined'
|
||||
);
|
||||
});
|
||||
});
|
||||
@ -1,79 +0,0 @@
|
||||
import { expect } from 'chai';
|
||||
import { beforeEach } from 'mocha';
|
||||
|
||||
import { SessionRequestMessage } from '../../../../session/messages/outgoing';
|
||||
import { SignalService } from '../../../../protobuf';
|
||||
import { TextDecoder, TextEncoder } from 'util';
|
||||
import { Constants } from '../../../../session';
|
||||
|
||||
describe('SessionRequestMessage', () => {
|
||||
let message: SessionRequestMessage;
|
||||
const preKeyBundle = {
|
||||
deviceId: 123456,
|
||||
preKeyId: 654321,
|
||||
signedKeyId: 111111,
|
||||
preKey: new TextEncoder().encode('preKey'),
|
||||
signature: new TextEncoder().encode('signature'),
|
||||
signedKey: new TextEncoder().encode('signedKey'),
|
||||
identityKey: new TextEncoder().encode('identityKey'),
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
const timestamp = Date.now();
|
||||
message = new SessionRequestMessage({ timestamp, preKeyBundle });
|
||||
});
|
||||
|
||||
it('has a preKeyBundle', () => {
|
||||
const plainText = message.plainTextBuffer();
|
||||
const decoded = SignalService.Content.decode(plainText);
|
||||
|
||||
expect(decoded.preKeyBundleMessage).to.have.property(
|
||||
'deviceId',
|
||||
preKeyBundle.deviceId
|
||||
);
|
||||
expect(decoded.preKeyBundleMessage).to.have.property(
|
||||
'preKeyId',
|
||||
preKeyBundle.preKeyId
|
||||
);
|
||||
expect(decoded.preKeyBundleMessage).to.have.property(
|
||||
'signedKeyId',
|
||||
preKeyBundle.signedKeyId
|
||||
);
|
||||
|
||||
const signature = new TextDecoder().decode(
|
||||
decoded.preKeyBundleMessage?.signature
|
||||
);
|
||||
const signedKey = new TextDecoder().decode(
|
||||
decoded.preKeyBundleMessage?.signedKey
|
||||
);
|
||||
const identityKey = new TextDecoder().decode(
|
||||
decoded.preKeyBundleMessage?.identityKey
|
||||
);
|
||||
|
||||
expect(signature).to.be.deep.equal('signature');
|
||||
expect(signedKey).to.be.deep.equal('signedKey');
|
||||
expect(identityKey).to.be.deep.equal('identityKey');
|
||||
});
|
||||
|
||||
it('has a nullMessage not null', () => {
|
||||
const plainText = message.plainTextBuffer();
|
||||
const decoded = SignalService.Content.decode(plainText);
|
||||
|
||||
expect(decoded.nullMessage).to.be.not.equal(
|
||||
null,
|
||||
'decoded.dataMessage.nullMessage should not be null'
|
||||
);
|
||||
});
|
||||
|
||||
it('correct ttl', () => {
|
||||
expect(message.ttl()).to.equal(Constants.TTL_DEFAULT.SESSION_REQUEST);
|
||||
});
|
||||
|
||||
it('has an identifier', () => {
|
||||
expect(message.identifier).to.not.equal(null, 'identifier cannot be null');
|
||||
expect(message.identifier).to.not.equal(
|
||||
undefined,
|
||||
'identifier cannot be undefined'
|
||||
);
|
||||
});
|
||||
});
|
||||
@ -1,403 +0,0 @@
|
||||
import { expect } from 'chai';
|
||||
import * as sinon from 'sinon';
|
||||
import { SessionProtocol } from '../../../../session/protocols';
|
||||
import { Stubs, TestUtils } from '../../../test-utils';
|
||||
import { UserUtil } from '../../../../util';
|
||||
import { SessionRequestMessage } from '../../../../session/messages/outgoing';
|
||||
import { TextEncoder } from 'util';
|
||||
import { MessageSender } from '../../../../session/sending';
|
||||
import { PubKey } from '../../../../session/types';
|
||||
import { Constants } from '../../../../session';
|
||||
|
||||
// tslint:disable-next-line: max-func-body-length
|
||||
describe('SessionProtocol', () => {
|
||||
const sandbox = sinon.createSandbox();
|
||||
const ourNumber = TestUtils.generateFakePubKey();
|
||||
const pubkey = TestUtils.generateFakePubKey();
|
||||
let getItemById: sinon.SinonStub;
|
||||
let send: sinon.SinonStub;
|
||||
|
||||
const resetMessage: SessionRequestMessage = new SessionRequestMessage({
|
||||
timestamp: Date.now(),
|
||||
preKeyBundle: {
|
||||
identityKey: new TextEncoder().encode('identityKey'),
|
||||
deviceId: 1,
|
||||
preKeyId: 2,
|
||||
signedKeyId: 3,
|
||||
preKey: new TextEncoder().encode('preKey'),
|
||||
signedKey: new TextEncoder().encode('signedKey'),
|
||||
signature: new TextEncoder().encode('signature'),
|
||||
},
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
TestUtils.stubWindow('libsignal', {
|
||||
SignalProtocolAddress: sandbox.stub(),
|
||||
SessionCipher: Stubs.SessionCipherStub,
|
||||
} as any);
|
||||
|
||||
TestUtils.stubWindow('libloki', {
|
||||
storage: {
|
||||
getPreKeyBundleForContact: sandbox.stub(),
|
||||
},
|
||||
});
|
||||
|
||||
TestUtils.stubWindow('textsecure', {
|
||||
storage: {
|
||||
protocol: sandbox.stub(),
|
||||
},
|
||||
});
|
||||
|
||||
TestUtils.stubData('createOrUpdateItem');
|
||||
|
||||
getItemById = TestUtils.stubData('getItemById').resolves({ value: {} });
|
||||
|
||||
sandbox.stub(UserUtil, 'getCurrentDevicePubKey').resolves(ourNumber.key);
|
||||
send = sandbox.stub(MessageSender, 'send' as any);
|
||||
SessionProtocol.reset();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
sandbox.restore();
|
||||
TestUtils.restoreStubs();
|
||||
});
|
||||
|
||||
describe('db fetch', () => {
|
||||
it('protocol: should fetch from DB `sentSessionsTimestamp` and `processedSessionsTimestamp`', async () => {
|
||||
await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(getItemById.calledWith('sentSessionsTimestamp'));
|
||||
expect(getItemById.calledWith('processedSessionsTimestamp'));
|
||||
expect(getItemById.callCount).to.equal(2);
|
||||
});
|
||||
|
||||
it('protocol: should fetch only once', async () => {
|
||||
await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(getItemById.calledWith('sentSessionsTimestamp'));
|
||||
expect(getItemById.calledWith('processedSessionsTimestamp'));
|
||||
expect(getItemById.callCount).to.equal(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('sendSessionRequest', () => {
|
||||
beforeEach(async () => {
|
||||
// trigger a sessionReset
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey);
|
||||
});
|
||||
|
||||
it('protocol: sendSessionRequest should add the deviceID to the sentMap', async () => {
|
||||
expect(SessionProtocol.getSentSessionsTimestamp())
|
||||
.to.have.property(pubkey.key)
|
||||
.to.be.approximately(Date.now(), 100);
|
||||
});
|
||||
|
||||
it('protocol: sendSessionRequest should not have pendingSend set after', async () => {
|
||||
expect(
|
||||
SessionProtocol.getPendingSendSessionTimestamp()
|
||||
).to.not.have.property(pubkey.key);
|
||||
});
|
||||
});
|
||||
|
||||
describe('checkSessionRequestExpiry', () => {
|
||||
let clock: sinon.SinonFakeTimers;
|
||||
let now: number;
|
||||
let sendSessionRequestStub: sinon.SinonStub<
|
||||
[SessionRequestMessage, PubKey],
|
||||
Promise<void>
|
||||
>;
|
||||
beforeEach(() => {
|
||||
now = Date.now();
|
||||
clock = sandbox.useFakeTimers(now);
|
||||
|
||||
sendSessionRequestStub = sandbox
|
||||
.stub(SessionProtocol, 'sendSessionRequest')
|
||||
.resolves();
|
||||
});
|
||||
|
||||
it('should not send a session request if none have expired', async () => {
|
||||
getItemById.withArgs('sentSessionsTimestamp').resolves({
|
||||
id: 'sentSessionsTimestamp',
|
||||
value: {
|
||||
[pubkey.key]: now,
|
||||
},
|
||||
});
|
||||
|
||||
// Set the time just before expiry
|
||||
clock.tick(Constants.TTL_DEFAULT.SESSION_REQUEST - 100);
|
||||
|
||||
await SessionProtocol.checkSessionRequestExpiry();
|
||||
expect(getItemById.calledWith('sentSessionsTimestamp'));
|
||||
expect(sendSessionRequestStub.callCount).to.equal(0);
|
||||
});
|
||||
|
||||
it('should send a session request if expired', async () => {
|
||||
getItemById.withArgs('sentSessionsTimestamp').resolves({
|
||||
id: 'sentSessionsTimestamp',
|
||||
value: {
|
||||
[pubkey.key]: now,
|
||||
},
|
||||
});
|
||||
|
||||
// Expire the request
|
||||
clock.tick(Constants.TTL_DEFAULT.SESSION_REQUEST + 100);
|
||||
|
||||
await SessionProtocol.checkSessionRequestExpiry();
|
||||
expect(getItemById.calledWith('sentSessionsTimestamp'));
|
||||
expect(sendSessionRequestStub.callCount).to.equal(1);
|
||||
});
|
||||
|
||||
it('should remove the old sent timestamp when expired', async () => {
|
||||
getItemById.withArgs('sentSessionsTimestamp').resolves({
|
||||
id: 'sentSessionsTimestamp',
|
||||
value: {
|
||||
[pubkey.key]: now,
|
||||
},
|
||||
});
|
||||
|
||||
// Remove this call from the equation
|
||||
sandbox.stub(SessionProtocol, 'sendSessionRequestIfNeeded').resolves();
|
||||
|
||||
// Expire the request
|
||||
clock.tick(Constants.TTL_DEFAULT.SESSION_REQUEST + 100);
|
||||
|
||||
await SessionProtocol.checkSessionRequestExpiry();
|
||||
expect(getItemById.calledWith('sentSessionsTimestamp'));
|
||||
expect(await SessionProtocol.hasSentSessionRequest(pubkey)).to.equal(
|
||||
false,
|
||||
'hasSentSessionRequest should return false.'
|
||||
);
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.not.have.property(
|
||||
pubkey.key
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('onSessionEstablished', () => {
|
||||
beforeEach(async () => {
|
||||
// add an existing entry in the sentMap
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey);
|
||||
});
|
||||
|
||||
it('protocol: onSessionEstablished should remove the device in sentTimestamps', async () => {
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.have.property(
|
||||
pubkey.key
|
||||
);
|
||||
await SessionProtocol.onSessionEstablished(pubkey);
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.not.have.property(
|
||||
pubkey.key
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: onSessionEstablished should remove the device in sentTimestamps and ONLY that one', async () => {
|
||||
// add a second item to the map
|
||||
const anotherPubKey = TestUtils.generateFakePubKey();
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, anotherPubKey);
|
||||
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.have.property(
|
||||
pubkey.key
|
||||
);
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.have.property(
|
||||
anotherPubKey.key
|
||||
);
|
||||
|
||||
await SessionProtocol.onSessionEstablished(pubkey);
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.not.have.property(
|
||||
pubkey.key
|
||||
);
|
||||
expect(SessionProtocol.getSentSessionsTimestamp()).to.have.property(
|
||||
anotherPubKey.key
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('hasSentSessionRequest', () => {
|
||||
it('protocol: hasSentSessionRequest returns false if a message was not sent to that device', async () => {
|
||||
const hasSent = await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(hasSent).to.be.equal(
|
||||
false,
|
||||
`hasSent should be false for ${pubkey.key}`
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: hasSentSessionRequest returns true if a message is already sent for that device', async () => {
|
||||
// add an existing entry in the sentMap
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey);
|
||||
const hasSent = await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(hasSent).to.be.equal(
|
||||
true,
|
||||
`hasSent should be true for ${pubkey.key}`
|
||||
);
|
||||
});
|
||||
|
||||
// TODO add a test to validate that pending is filled when message is triggered and not yet sent
|
||||
});
|
||||
|
||||
describe('sendSessionRequestIfNeeded', () => {
|
||||
it('protocol: sendSessionRequestIfNeeded should send a new sessionMessage ', async () => {
|
||||
// not called before, so the message reset sending should be triggered
|
||||
await SessionProtocol.sendSessionRequestIfNeeded(pubkey);
|
||||
expect(send.callCount).to.be.equal(
|
||||
1,
|
||||
'MessageSender.send() should have been called'
|
||||
);
|
||||
|
||||
// check that the map is updated with that ID
|
||||
const hasSent = await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(hasSent).to.be.equal(
|
||||
true,
|
||||
`hasSent should be true for ${pubkey.key}`
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: sendSessionRequestIfNeeded should NOT send a new sessionMessage on second try ', async () => {
|
||||
await SessionProtocol.sendSessionRequestIfNeeded(pubkey);
|
||||
expect(send.callCount).to.be.equal(
|
||||
1,
|
||||
'MessageSender.send() should have been called'
|
||||
);
|
||||
|
||||
// check that the map is updated with that ID
|
||||
const hasSent = await SessionProtocol.hasSentSessionRequest(pubkey);
|
||||
expect(hasSent).to.be.equal(
|
||||
true,
|
||||
`hasSent should be true for ${pubkey.key}`
|
||||
);
|
||||
send.resetHistory();
|
||||
|
||||
// trigger a second call, Message.send().calledCount should still be 1
|
||||
await SessionProtocol.sendSessionRequestIfNeeded(pubkey);
|
||||
expect(send.callCount).to.be.equal(
|
||||
0,
|
||||
'MessageSender.send() should NOT have been called a second time'
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('onSessionRequestProcessed', () => {
|
||||
it('protocol: onSessionRequestProcessed should insert a new item in the processedMap ', async () => {
|
||||
// trigger the requestProcessed and check the map is updated
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey);
|
||||
expect(SessionProtocol.getProcessedSessionsTimestamp())
|
||||
.to.have.property(pubkey.key)
|
||||
.to.be.approximately(Date.now(), 5);
|
||||
});
|
||||
|
||||
it('protocol: onSessionRequestProcessed should update an existing item in the processedMap ', async () => {
|
||||
// trigger the requestProcessed and check the map is updated
|
||||
// then trigger it a second time, and expect a change in the processed timestamp
|
||||
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey);
|
||||
expect(SessionProtocol.getProcessedSessionsTimestamp())
|
||||
.to.have.property(pubkey.key)
|
||||
.to.be.approximately(Date.now(), 5);
|
||||
await TestUtils.timeout(5);
|
||||
const oldTimestamp = SessionProtocol.getProcessedSessionsTimestamp()[
|
||||
pubkey.key
|
||||
];
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey);
|
||||
expect(SessionProtocol.getProcessedSessionsTimestamp())
|
||||
.to.have.property(pubkey.key)
|
||||
.to.be.approximately(Date.now(), 5)
|
||||
.to.not.be.equal(oldTimestamp);
|
||||
});
|
||||
});
|
||||
|
||||
describe('shouldProcessSessionRequest', () => {
|
||||
it('protocol: shouldProcessSessionRequest returns true if timestamp is more recent than processed timestamp', async () => {
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey); // adds a Date.now() entry
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, Date.now() + 1000)
|
||||
).to.be.eventually.equal(
|
||||
true,
|
||||
'shouldProcessSessionRequest should return true when existingProcessed is less recent'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns true if there is no processed timestamp yet for this device', async () => {
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, 100)
|
||||
).to.be.eventually.equal(
|
||||
true,
|
||||
'shouldProcessSessionRequest should return false when existingProcessed is empty for this device'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns false if timestamp is less recent than current processed timestamp', async () => {
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey); // adds a Date.now() entry
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, 100)
|
||||
).to.be.eventually.equal(
|
||||
false,
|
||||
'shouldProcessSessionRequest should return false when existingProcessed is more recent'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns false if timestamp is less recent than current sent timestamp', async () => {
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey); // adds a Date.now() entry
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, 100)
|
||||
).to.be.eventually.equal(
|
||||
false,
|
||||
'shouldProcessSessionRequest should return false when existingSent is more recent'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns true if timestamp is more recent than current sent timestamp', async () => {
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey); // adds a Date.now() entry
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, Date.now() + 1000)
|
||||
).to.be.eventually.equal(
|
||||
true,
|
||||
'shouldProcessSessionRequest should return true when existingSent is less recent'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns true if there is no sent timestamp', async () => {
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, 100)
|
||||
).to.be.eventually.equal(
|
||||
true,
|
||||
'shouldProcessSessionRequest should return true as there is no sent timestamp'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns false if there is a more recent sent but a less recent processed', async () => {
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey); // adds a Date.now() entry
|
||||
await TestUtils.timeout(100);
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey); // adds a Date.now() entry 100ms after
|
||||
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, Date.now() - 50)
|
||||
).to.be.eventually.equal(
|
||||
false,
|
||||
'shouldProcessSessionRequest should return false if there is a more recent sent but a less recent processed'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns false if there is a more recent processed but a less recent sent', async () => {
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey); // adds a Date.now() entry
|
||||
await TestUtils.timeout(100);
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey); // adds a Date.now() entry 100ms after
|
||||
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, Date.now() - 50)
|
||||
).to.be.eventually.equal(
|
||||
false,
|
||||
'shouldProcessSessionRequest should return false if there is a more recent processed but a less recent sent'
|
||||
);
|
||||
});
|
||||
|
||||
it('protocol: shouldProcessSessionRequest returns true if both sent and processed timestamp are older', async () => {
|
||||
await SessionProtocol.onSessionRequestProcessed(pubkey); // adds a Date.now() entry
|
||||
await SessionProtocol.sendSessionRequest(resetMessage, pubkey); // adds a Date.now() entry
|
||||
expect(
|
||||
SessionProtocol.shouldProcessSessionRequest(pubkey, Date.now() + 1000)
|
||||
).to.be.eventually.equal(
|
||||
true,
|
||||
'shouldProcessSessionRequest should return true if there if both processed and sent are set but are older'
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
Loading…
Reference in New Issue