signal-desktop/ts/textsecure/MessageReceiver.ts

3285 lines
94 KiB
TypeScript
Raw Normal View History

// Copyright 2020-2022 Signal Messenger, LLC
2020-10-30 20:34:04 +00:00
// SPDX-License-Identifier: AGPL-3.0-only
/* eslint-disable no-bitwise */
import { isBoolean, isNumber } from 'lodash';
import PQueue from 'p-queue';
import { v4 as getGuid } from 'uuid';
import type {
SealedSenderDecryptionResult,
SenderCertificate,
UnidentifiedSenderMessageContent,
} from '@signalapp/libsignal-client';
import {
CiphertextMessageType,
2021-05-28 19:11:19 +00:00
DecryptionErrorMessage,
groupDecrypt,
2021-05-28 19:11:19 +00:00
PlaintextContent,
PreKeySignalMessage,
processSenderKeyDistributionMessage,
ProtocolAddress,
PublicKey,
sealedSenderDecryptMessage,
sealedSenderDecryptToUsmc,
SenderKeyDistributionMessage,
signalDecrypt,
signalDecryptPreKey,
SignalMessage,
} from '@signalapp/libsignal-client';
import {
IdentityKeys,
PreKeys,
SenderKeys,
Sessions,
SignedPreKeys,
} from '../LibSignalStores';
import { verifySignature } from '../Curve';
import { strictAssert } from '../util/assert';
import type { BatcherType } from '../util/batcher';
import { createBatcher } from '../util/batcher';
2021-07-09 19:36:10 +00:00
import { dropNull } from '../util/dropNull';
import { normalizeUuid } from '../util/normalizeUuid';
import { parseIntOrThrow } from '../util/parseIntOrThrow';
import { clearTimeoutIfNecessary } from '../util/clearTimeoutIfNecessary';
2021-05-19 21:25:56 +00:00
import { Zone } from '../util/Zone';
2022-08-15 21:53:33 +00:00
import { deriveMasterKeyFromGroupV1, bytesToUuid } from '../Crypto';
import type { DownloadedAttachmentType } from '../types/Attachment';
import { Address } from '../types/Address';
import { QualifiedAddress } from '../types/QualifiedAddress';
import type { UUIDStringType } from '../types/UUID';
import { UUID, UUIDKind } from '../types/UUID';
import * as Errors from '../types/errors';
import { isEnabled } from '../RemoteConfig';
2021-07-09 19:36:10 +00:00
import { SignalService as Proto } from '../protobuf';
import { deriveGroupFields, MASTER_KEY_LENGTH } from '../groups';
import createTaskWithTimeout from './TaskWithTimeout';
2022-04-15 00:08:46 +00:00
import {
processAttachment,
processDataMessage,
processGroupV2Context,
} from './processDataMessage';
import { processSyncMessage } from './processSyncMessage';
import type { EventHandler } from './EventTarget';
import EventTarget from './EventTarget';
import { downloadAttachment } from './downloadAttachment';
import type { IncomingWebSocketRequest } from './WebsocketResources';
import { ContactBuffer, GroupBuffer } from './ContactsParser';
import type { WebAPIType } from './WebAPI';
import type { Storage } from './Storage';
2021-09-22 00:58:03 +00:00
import { WarnOnlyError } from './Errors';
import * as Bytes from '../Bytes';
import type {
2022-03-04 21:14:52 +00:00
ProcessedAttachment,
2021-07-09 19:36:10 +00:00
ProcessedDataMessage,
ProcessedSyncMessage,
ProcessedSent,
ProcessedEnvelope,
IRequestHandler,
UnprocessedType,
2021-07-09 19:36:10 +00:00
} from './Types.d';
import {
2021-07-09 19:36:10 +00:00
EmptyEvent,
EnvelopeEvent,
2021-07-09 19:36:10 +00:00
ProgressEvent,
TypingEvent,
ErrorEvent,
DeliveryEvent,
DecryptionErrorEvent,
SentEvent,
ProfileKeyUpdateEvent,
MessageEvent,
RetryRequestEvent,
ReadEvent,
ViewEvent,
2021-07-09 19:36:10 +00:00
ConfigurationEvent,
ViewOnceOpenSyncEvent,
2021-07-09 19:36:10 +00:00
MessageRequestResponseEvent,
FetchLatestEvent,
KeysEvent,
StickerPackEvent,
ReadSyncEvent,
ViewSyncEvent,
2021-07-09 19:36:10 +00:00
ContactSyncEvent,
GroupEvent,
GroupSyncEvent,
2022-07-13 23:09:18 +00:00
StoryRecipientUpdateEvent,
2021-07-09 19:36:10 +00:00
} from './messageReceiverEvents';
import * as log from '../logging/log';
2022-03-04 21:14:52 +00:00
import * as durations from '../util/durations';
import { areArraysMatchingSets } from '../util/areArraysMatchingSets';
2022-04-06 01:18:07 +00:00
import { generateBlurHash } from '../util/generateBlurHash';
2022-08-02 19:31:55 +00:00
import { TEXT_ATTACHMENT } from '../types/MIME';
import type { SendTypesType } from '../util/handleMessageSend';
2020-11-20 17:30:45 +00:00
const GROUPV1_ID_LENGTH = 16;
const GROUPV2_ID_LENGTH = 32;
const RETRY_TIMEOUT = 2 * 60 * 1000;
type UnsealedEnvelope = Readonly<
2022-08-15 21:53:33 +00:00
Omit<ProcessedEnvelope, 'sourceUuid'> & {
sourceUuid: UUIDStringType;
2021-07-09 19:36:10 +00:00
unidentifiedDeliveryReceived?: boolean;
contentHint?: number;
2020-05-27 21:37:06 +00:00
groupId?: string;
cipherTextBytes?: Uint8Array;
cipherTextType?: number;
certificate?: SenderCertificate;
unsealedContent?: UnidentifiedSenderMessageContent;
}
2021-07-09 19:36:10 +00:00
>;
2022-08-15 21:53:33 +00:00
type DecryptResult = Readonly<
| {
envelope: UnsealedEnvelope;
plaintext: Uint8Array;
}
| {
envelope?: UnsealedEnvelope;
plaintext?: undefined;
}
>;
2021-07-09 19:36:10 +00:00
type DecryptSealedSenderResult = Readonly<{
plaintext?: Uint8Array;
unsealedPlaintext?: SealedSenderDecryptionResult;
}>;
type CacheAddItemType = {
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope;
data: UnprocessedType;
2021-05-24 21:30:56 +00:00
request: Pick<IncomingWebSocketRequest, 'respond'>;
};
type LockedStores = {
readonly senderKeyStore: SenderKeys;
readonly sessionStore: Sessions;
readonly identityKeyStore: IdentityKeys;
readonly zone?: Zone;
};
enum TaskType {
Encrypted = 'Encrypted',
Decrypted = 'Decrypted',
}
export type MessageReceiverOptions = {
server: WebAPIType;
storage: Storage;
serverTrustRoot: string;
};
2021-06-09 22:28:54 +00:00
const LOG_UNEXPECTED_URGENT_VALUES = false;
const MUST_BE_URGENT_TYPES: Array<SendTypesType> = [
'message',
'deleteForEveryone',
'reaction',
'readSync',
];
const CAN_BE_URGENT_TYPES: Array<SendTypesType> = [
'callingMessage',
'senderKeyDistributionMessage',
// Deprecated
'resetSession',
'legacyGroupChange',
];
function logUnexpectedUrgentValue(
envelope: ProcessedEnvelope,
type: SendTypesType
) {
if (!LOG_UNEXPECTED_URGENT_VALUES) {
return;
}
const mustBeUrgent = MUST_BE_URGENT_TYPES.includes(type);
const canBeUrgent = mustBeUrgent || CAN_BE_URGENT_TYPES.includes(type);
if (envelope.urgent && !canBeUrgent) {
const envelopeId = getEnvelopeId(envelope);
log.warn(
`${envelopeId}: Message of type '${type}' was marked urgent, but shouldn't be!`
);
}
if (!envelope.urgent && mustBeUrgent) {
const envelopeId = getEnvelopeId(envelope);
log.warn(
`${envelopeId}: Message of type '${type}' wasn't marked urgent, but should be!`
);
}
}
function getEnvelopeId(envelope: ProcessedEnvelope): string {
const { timestamp } = envelope;
let prefix = '';
if (envelope.sourceUuid || envelope.source) {
const sender = envelope.sourceUuid || envelope.source;
prefix += `${sender}.${envelope.sourceDevice} `;
}
prefix += `> ${envelope.destinationUuid.toString()}`;
return `${prefix} ${timestamp} (${envelope.id})`;
}
2022-09-13 21:48:09 +00:00
/* eslint-disable @typescript-eslint/brace-style -- Prettier conflicts with ESLint */
export default class MessageReceiver
extends EventTarget
2021-11-11 22:43:05 +00:00
implements IRequestHandler
{
2022-09-13 21:48:09 +00:00
/* eslint-enable @typescript-eslint/brace-style */
private server: WebAPIType;
2021-07-09 19:36:10 +00:00
private storage: Storage;
private appQueue: PQueue;
private decryptAndCacheBatcher: BatcherType<CacheAddItemType>;
private cacheRemoveBatcher: BatcherType<string>;
private count: number;
private processedCount: number;
private incomingQueue: PQueue;
private isEmptied?: boolean;
private encryptedQueue: PQueue;
private decryptedQueue: PQueue;
private retryCachedTimeout: NodeJS.Timeout | undefined;
private serverTrustRoot: Uint8Array;
private stoppingProcessing?: boolean;
constructor({ server, storage, serverTrustRoot }: MessageReceiverOptions) {
super();
this.server = server;
this.storage = storage;
this.count = 0;
this.processedCount = 0;
if (!serverTrustRoot) {
throw new Error('Server trust root is required!');
}
this.serverTrustRoot = Bytes.fromBase64(serverTrustRoot);
2021-11-23 22:01:03 +00:00
this.incomingQueue = new PQueue({
concurrency: 1,
throwOnTimeout: true,
});
this.appQueue = new PQueue({
concurrency: 1,
throwOnTimeout: true,
});
// All envelopes start in encryptedQueue and progress to decryptedQueue
this.encryptedQueue = new PQueue({
concurrency: 1,
2021-11-23 22:01:03 +00:00
throwOnTimeout: true,
});
this.decryptedQueue = new PQueue({
concurrency: 1,
2021-11-23 22:01:03 +00:00
throwOnTimeout: true,
});
2021-05-24 21:30:56 +00:00
this.decryptAndCacheBatcher = createBatcher<CacheAddItemType>({
name: 'MessageReceiver.decryptAndCacheBatcher',
wait: 75,
maxSize: 30,
2021-03-26 00:00:03 +00:00
processBatch: (items: Array<CacheAddItemType>) => {
// Not returning the promise here because we don't want to stall
// the batch.
2021-05-24 21:30:56 +00:00
this.decryptAndCacheBatch(items);
2021-03-26 00:00:03 +00:00
},
});
this.cacheRemoveBatcher = createBatcher<string>({
2021-03-26 00:00:03 +00:00
name: 'MessageReceiver.cacheRemoveBatcher',
wait: 75,
maxSize: 30,
processBatch: this.cacheRemoveBatch.bind(this),
});
}
public getAndResetProcessedCount(): number {
const count = this.processedCount;
this.processedCount = 0;
return count;
}
public handleRequest(request: IncomingWebSocketRequest): void {
// We do the message decryption here, instead of in the ordered pending queue,
// to avoid exposing the time it took us to process messages through the time-to-ack.
log.info('MessageReceiver: got request', request.verb, request.path);
if (request.path !== '/api/v1/message') {
request.respond(200, 'OK');
if (request.verb === 'PUT' && request.path === '/api/v1/queue/empty') {
this.incomingQueue.add(
createTaskWithTimeout(async () => {
this.onEmpty();
}, 'incomingQueue/onEmpty')
);
}
return;
}
2021-06-09 22:28:54 +00:00
const job = async () => {
const headers = request.headers || [];
2021-06-09 22:28:54 +00:00
if (!request.body) {
throw new Error(
'MessageReceiver.handleRequest: request.body was falsey!'
);
2021-06-23 14:47:42 +00:00
}
const plaintext = request.body;
2021-06-09 22:28:54 +00:00
try {
const decoded = Proto.Envelope.decode(plaintext);
2022-03-23 20:49:27 +00:00
const serverTimestamp = decoded.serverTimestamp?.toNumber();
2021-06-09 22:28:54 +00:00
const ourUuid = this.storage.user.getCheckedUuid();
const envelope: ProcessedEnvelope = {
// Make non-private envelope IDs dashless so they don't get redacted
// from logs
id: getGuid().replace(/-/g, ''),
receivedAtCounter: window.Signal.Util.incrementMessageCounter(),
receivedAtDate: Date.now(),
// Calculate the message age (time on server).
messageAgeSec: this.calculateMessageAge(headers, serverTimestamp),
2021-06-09 22:28:54 +00:00
// Proto.Envelope fields
type: decoded.type,
sourceUuid: decoded.sourceUuid
? normalizeUuid(
decoded.sourceUuid,
'MessageReceiver.handleRequest.sourceUuid'
)
: undefined,
sourceDevice: decoded.sourceDevice,
destinationUuid: decoded.destinationUuid
? new UUID(
normalizeUuid(
decoded.destinationUuid,
'MessageReceiver.handleRequest.destinationUuid'
)
)
: ourUuid,
2022-07-28 16:35:29 +00:00
updatedPni: decoded.updatedPni
? new UUID(
normalizeUuid(
decoded.updatedPni,
'MessageReceiver.handleRequest.updatedPni'
)
)
: undefined,
2022-03-23 20:49:27 +00:00
timestamp: decoded.timestamp?.toNumber(),
content: dropNull(decoded.content),
serverGuid: decoded.serverGuid,
serverTimestamp,
urgent: isBoolean(decoded.urgent) ? decoded.urgent : true,
};
2021-06-09 22:28:54 +00:00
// After this point, decoding errors are not the server's
// fault, and we should handle them gracefully and tell the
// user they received an invalid message
2021-06-09 22:28:54 +00:00
this.decryptAndCache(envelope, plaintext, request);
this.processedCount += 1;
} catch (e) {
request.respond(500, 'Bad encrypted websocket message');
log.error('Error handling incoming message:', Errors.toLogFormat(e));
await this.dispatchAndWait(new ErrorEvent(e));
}
};
this.incomingQueue.add(
createTaskWithTimeout(job, 'incomingQueue/websocket')
);
}
public reset(): void {
// We always process our cache before processing a new websocket message
this.incomingQueue.add(
createTaskWithTimeout(
async () => this.queueAllCached(),
'incomingQueue/queueAllCached'
)
);
this.count = 0;
this.isEmptied = false;
this.stoppingProcessing = false;
}
public stopProcessing(): void {
log.info('MessageReceiver.stopProcessing');
this.stoppingProcessing = true;
}
public hasEmptied(): boolean {
return Boolean(this.isEmptied);
}
public async drain(): Promise<void> {
const waitForEncryptedQueue = async () =>
this.addToQueue(
async () => {
log.info('drained');
},
'drain/waitForDecrypted',
TaskType.Decrypted
);
const waitForIncomingQueue = async () =>
this.addToQueue(
waitForEncryptedQueue,
'drain/waitForEncrypted',
TaskType.Encrypted
);
return this.incomingQueue.add(
createTaskWithTimeout(waitForIncomingQueue, 'drain/waitForIncoming')
);
}
//
// EventTarget types
//
public override addEventListener(
name: 'empty',
handler: (ev: EmptyEvent) => void
): void;
public override addEventListener(
name: 'progress',
handler: (ev: ProgressEvent) => void
): void;
public override addEventListener(
name: 'typing',
handler: (ev: TypingEvent) => void
): void;
public override addEventListener(
name: 'error',
handler: (ev: ErrorEvent) => void
): void;
public override addEventListener(
name: 'delivery',
handler: (ev: DeliveryEvent) => void
): void;
public override addEventListener(
name: 'decryption-error',
handler: (ev: DecryptionErrorEvent) => void
): void;
public override addEventListener(
name: 'sent',
handler: (ev: SentEvent) => void
): void;
public override addEventListener(
name: 'profileKeyUpdate',
handler: (ev: ProfileKeyUpdateEvent) => void
): void;
public override addEventListener(
name: 'message',
handler: (ev: MessageEvent) => void
): void;
public override addEventListener(
name: 'retry-request',
handler: (ev: RetryRequestEvent) => void
): void;
public override addEventListener(
name: 'read',
handler: (ev: ReadEvent) => void
): void;
public override addEventListener(
name: 'view',
handler: (ev: ViewEvent) => void
): void;
public override addEventListener(
name: 'configuration',
handler: (ev: ConfigurationEvent) => void
): void;
public override addEventListener(
name: 'viewOnceOpenSync',
handler: (ev: ViewOnceOpenSyncEvent) => void
): void;
public override addEventListener(
name: 'messageRequestResponse',
handler: (ev: MessageRequestResponseEvent) => void
): void;
public override addEventListener(
name: 'fetchLatest',
handler: (ev: FetchLatestEvent) => void
): void;
public override addEventListener(
name: 'keys',
handler: (ev: KeysEvent) => void
): void;
public override addEventListener(
name: 'sticker-pack',
handler: (ev: StickerPackEvent) => void
): void;
public override addEventListener(
name: 'readSync',
handler: (ev: ReadSyncEvent) => void
): void;
public override addEventListener(
name: 'viewSync',
handler: (ev: ViewSyncEvent) => void
): void;
public override addEventListener(
name: 'contactSync',
handler: (ev: ContactSyncEvent) => void
): void;
public override addEventListener(
name: 'group',
handler: (ev: GroupEvent) => void
): void;
public override addEventListener(
name: 'groupSync',
handler: (ev: GroupSyncEvent) => void
): void;
public override addEventListener(
2021-08-05 23:34:49 +00:00
name: 'envelope',
handler: (ev: EnvelopeEvent) => void
): void;
2022-07-13 23:09:18 +00:00
public override addEventListener(
name: 'storyRecipientUpdate',
handler: (ev: StoryRecipientUpdateEvent) => void
): void;
public override addEventListener(name: string, handler: EventHandler): void {
return super.addEventListener(name, handler);
}
public override removeEventListener(
name: string,
handler: EventHandler
): void {
return super.removeEventListener(name, handler);
}
//
// Private
//
private async dispatchAndWait(event: Event): Promise<void> {
this.appQueue.add(
createTaskWithTimeout(
async () => Promise.all(this.dispatchEvent(event)),
'dispatchEvent'
)
);
}
private calculateMessageAge(
2021-07-02 19:21:24 +00:00
headers: ReadonlyArray<string>,
serverTimestamp?: number
): number {
let messageAgeSec = 0; // Default to 0 in case of unreliable parameters.
if (serverTimestamp) {
// The 'X-Signal-Timestamp' is usually the last item, so start there.
let it = headers.length;
// eslint-disable-next-line no-plusplus
while (--it >= 0) {
const match = headers[it].match(/^X-Signal-Timestamp:\s*(\d+)\s*$/);
if (match && match.length === 2) {
const timestamp = Number(match[1]);
// One final sanity check, the timestamp when a message is pulled from
// the server should be later than when it was pushed.
if (timestamp > serverTimestamp) {
messageAgeSec = Math.floor((timestamp - serverTimestamp) / 1000);
}
break;
}
}
}
return messageAgeSec;
}
private async addToQueue<T>(
task: () => Promise<T>,
id: string,
taskType: TaskType
): Promise<T> {
if (taskType === TaskType.Encrypted) {
this.count += 1;
}
const queue =
taskType === TaskType.Encrypted
? this.encryptedQueue
: this.decryptedQueue;
try {
return await queue.add(createTaskWithTimeout(task, id));
} finally {
this.updateProgress(this.count);
}
}
private onEmpty(): void {
2021-03-26 00:00:03 +00:00
const emitEmpty = async () => {
await Promise.all([
2021-05-24 21:30:56 +00:00
this.decryptAndCacheBatcher.flushAndWait(),
2021-03-26 00:00:03 +00:00
this.cacheRemoveBatcher.flushAndWait(),
]);
log.info("MessageReceiver: emitting 'empty' event");
2021-07-09 19:36:10 +00:00
this.dispatchEvent(new EmptyEvent());
this.isEmptied = true;
this.maybeScheduleRetryTimeout();
};
const waitForDecryptedQueue = async () => {
log.info(
"MessageReceiver: finished processing messages after 'empty', now waiting for application"
);
2019-07-09 18:46:48 +00:00
// We don't await here because we don't want this to gate future message processing
this.appQueue.add(createTaskWithTimeout(emitEmpty, 'emitEmpty'));
};
const waitForEncryptedQueue = async () => {
this.addToQueue(
waitForDecryptedQueue,
'onEmpty/waitForDecrypted',
TaskType.Decrypted
);
};
const waitForIncomingQueue = async () => {
2019-07-09 18:46:48 +00:00
// Note: this.count is used in addToQueue
// Resetting count so everything from the websocket after this starts at zero
this.count = 0;
this.addToQueue(
waitForEncryptedQueue,
'onEmpty/waitForEncrypted',
TaskType.Encrypted
);
};
2019-09-26 19:56:31 +00:00
const waitForCacheAddBatcher = async () => {
2021-05-24 21:30:56 +00:00
await this.decryptAndCacheBatcher.onIdle();
this.incomingQueue.add(
createTaskWithTimeout(waitForIncomingQueue, 'onEmpty/waitForIncoming')
);
2019-09-26 19:56:31 +00:00
};
waitForCacheAddBatcher();
}
private updateProgress(count: number): void {
// count by 10s
if (count % 10 !== 0) {
return;
}
2021-07-09 19:36:10 +00:00
this.dispatchEvent(new ProgressEvent({ count }));
}
private async queueAllCached(): Promise<void> {
const items = await this.getAllFromCache();
const max = items.length;
for (let i = 0; i < max; i += 1) {
// eslint-disable-next-line no-await-in-loop
await this.queueCached(items[i]);
}
}
private async queueCached(item: UnprocessedType): Promise<void> {
log.info('MessageReceiver.queueCached', item.id);
try {
2021-07-09 19:36:10 +00:00
let envelopePlaintext: Uint8Array;
if (item.envelope && item.version === 2) {
2021-07-09 19:36:10 +00:00
envelopePlaintext = Bytes.fromBase64(item.envelope);
2021-05-24 21:30:56 +00:00
} else if (item.envelope && typeof item.envelope === 'string') {
2021-07-09 19:36:10 +00:00
envelopePlaintext = Bytes.fromBinary(item.envelope);
} else {
throw new Error(
'MessageReceiver.queueCached: item.envelope was malformed'
);
}
2021-07-09 19:36:10 +00:00
const decoded = Proto.Envelope.decode(envelopePlaintext);
const ourUuid = this.storage.user.getCheckedUuid();
2021-07-09 19:36:10 +00:00
const envelope: ProcessedEnvelope = {
id: item.id,
receivedAtCounter: item.receivedAtCounter ?? item.timestamp,
receivedAtDate:
item.receivedAtCounter == null ? Date.now() : item.timestamp,
2021-07-09 19:36:10 +00:00
messageAgeSec: item.messageAgeSec || 0,
// Proto.Envelope fields
type: decoded.type,
2022-08-02 16:19:21 +00:00
source: item.source,
2022-08-15 21:53:33 +00:00
sourceUuid:
item.sourceUuid ||
(decoded.sourceUuid ? UUID.cast(decoded.sourceUuid) : undefined),
2021-07-09 19:36:10 +00:00
sourceDevice: decoded.sourceDevice || item.sourceDevice,
destinationUuid: new UUID(
decoded.destinationUuid || item.destinationUuid || ourUuid.toString()
),
2022-07-28 16:35:29 +00:00
updatedPni: decoded.updatedPni
? new UUID(decoded.updatedPni)
: undefined,
2022-03-23 20:49:27 +00:00
timestamp: decoded.timestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
content: dropNull(decoded.content),
serverGuid: decoded.serverGuid,
2022-03-23 20:49:27 +00:00
serverTimestamp:
item.serverTimestamp || decoded.serverTimestamp?.toNumber(),
urgent: isBoolean(item.urgent) ? item.urgent : true,
2021-07-09 19:36:10 +00:00
};
const { decrypted } = item;
if (decrypted) {
2021-07-09 19:36:10 +00:00
let payloadPlaintext: Uint8Array;
if (item.version === 2) {
2021-07-09 19:36:10 +00:00
payloadPlaintext = Bytes.fromBase64(decrypted);
} else if (typeof decrypted === 'string') {
2021-07-09 19:36:10 +00:00
payloadPlaintext = Bytes.fromBinary(decrypted);
} else {
throw new Error('Cached decrypted value was not a string!');
}
2022-08-15 21:53:33 +00:00
strictAssert(
envelope.sourceUuid,
'Decrypted envelope must have source uuid'
);
// Pacify typescript
const decryptedEnvelope = {
...envelope,
sourceUuid: envelope.sourceUuid,
};
// Maintain invariant: encrypted queue => decrypted queue
this.addToQueue(
async () => {
2022-08-15 21:53:33 +00:00
this.queueDecryptedEnvelope(decryptedEnvelope, payloadPlaintext);
},
'queueDecryptedEnvelope',
TaskType.Encrypted
);
} else {
2021-05-24 21:30:56 +00:00
this.queueCachedEnvelope(item, envelope);
}
} catch (error) {
log.error(
'queueCached error handling item',
item.id,
'removing it. Error:',
Errors.toLogFormat(error)
);
try {
const { id } = item;
await this.storage.protocol.removeUnprocessed(id);
} catch (deleteError) {
log.error(
'queueCached error deleting item',
item.id,
'Error:',
Errors.toLogFormat(deleteError)
);
}
}
}
private clearRetryTimeout(): void {
clearTimeoutIfNecessary(this.retryCachedTimeout);
this.retryCachedTimeout = undefined;
}
private maybeScheduleRetryTimeout(): void {
if (this.isEmptied) {
this.clearRetryTimeout();
this.retryCachedTimeout = setTimeout(() => {
this.incomingQueue.add(
createTaskWithTimeout(
async () => this.queueAllCached(),
'queueAllCached'
)
);
}, RETRY_TIMEOUT);
}
}
private async getAllFromCache(): Promise<Array<UnprocessedType>> {
log.info('getAllFromCache');
const count = await this.storage.protocol.getUnprocessedCount();
if (count > 1500) {
await this.storage.protocol.removeAllUnprocessed();
log.warn(
`There were ${count} messages in cache. Deleted all instead of reprocessing`
);
return [];
}
const items =
await this.storage.protocol.getAllUnprocessedAndIncrementAttempts();
log.info('getAllFromCache loaded', items.length, 'saved envelopes');
return items;
}
private async decryptAndCacheBatch(
items: Array<CacheAddItemType>
): Promise<void> {
log.info('MessageReceiver.decryptAndCacheBatch', items.length);
2021-07-09 19:36:10 +00:00
const decrypted: Array<
Readonly<{
plaintext: Uint8Array;
data: UnprocessedType;
envelope: UnsealedEnvelope;
2021-07-09 19:36:10 +00:00
}>
> = [];
const storageProtocol = this.storage.protocol;
2019-09-26 19:56:31 +00:00
try {
2021-05-24 21:30:56 +00:00
const zone = new Zone('decryptAndCacheBatch', {
pendingSenderKeys: true,
2021-05-19 21:25:56 +00:00
pendingSessions: true,
pendingUnprocessed: true,
});
const storesMap = new Map<UUIDStringType, LockedStores>();
const failed: Array<UnprocessedType> = [];
// Below we:
//
2021-05-19 21:25:56 +00:00
// 1. Enter zone
// 2. Decrypt all batched envelopes
// 3. Persist both decrypted envelopes and envelopes that we failed to
// decrypt (for future retries, see `attempts` field)
2021-05-19 21:25:56 +00:00
// 4. Leave zone and commit all pending sessions and unprocesseds
// 5. Acknowledge envelopes (can't fail)
// 6. Finally process decrypted envelopes
2021-05-19 21:25:56 +00:00
await storageProtocol.withZone(zone, 'MessageReceiver', async () => {
await Promise.all<void>(
items.map(async ({ data, envelope }) => {
try {
const { destinationUuid } = envelope;
let stores = storesMap.get(destinationUuid.toString());
if (!stores) {
stores = {
senderKeyStore: new SenderKeys({
ourUuid: destinationUuid,
zone,
}),
sessionStore: new Sessions({
zone,
ourUuid: destinationUuid,
}),
identityKeyStore: new IdentityKeys({
zone,
ourUuid: destinationUuid,
}),
zone,
};
storesMap.set(destinationUuid.toString(), stores);
}
2021-07-09 19:36:10 +00:00
const result = await this.queueEncryptedEnvelope(
stores,
2022-07-28 16:35:29 +00:00
envelope
);
2021-07-09 19:36:10 +00:00
if (result.plaintext) {
decrypted.push({
plaintext: result.plaintext,
envelope: result.envelope,
data,
});
}
} catch (error) {
failed.push(data);
log.error(
'MessageReceiver.decryptAndCacheBatch error when ' +
'processing the envelope',
Errors.toLogFormat(error)
);
}
})
);
log.info(
2021-05-24 21:30:56 +00:00
'MessageReceiver.decryptAndCacheBatch storing ' +
`${decrypted.length} decrypted envelopes, keeping ` +
`${failed.length} failed envelopes.`
);
// Store both decrypted and failed unprocessed envelopes
const unprocesseds: Array<UnprocessedType> = decrypted.map(
({ envelope, data, plaintext }) => {
return {
...data,
source: envelope.source,
sourceUuid: envelope.sourceUuid,
sourceDevice: envelope.sourceDevice,
destinationUuid: envelope.destinationUuid.toString(),
2022-07-28 16:35:29 +00:00
updatedPni: envelope.updatedPni?.toString(),
serverGuid: envelope.serverGuid,
serverTimestamp: envelope.serverTimestamp,
2021-07-09 19:36:10 +00:00
decrypted: Bytes.toBase64(plaintext),
};
}
);
2021-05-19 21:25:56 +00:00
await storageProtocol.addMultipleUnprocessed(
unprocesseds.concat(failed),
{ zone }
);
});
log.info('MessageReceiver.decryptAndCacheBatch acknowledging receipt');
// Acknowledge all envelopes
for (const { request } of items) {
try {
request.respond(200, 'OK');
} catch (error) {
log.error(
2021-05-24 21:30:56 +00:00
'decryptAndCacheBatch: Failed to send 200 to server; still queuing envelope'
);
}
}
2019-09-26 19:56:31 +00:00
} catch (error) {
log.error(
2021-05-24 21:30:56 +00:00
'decryptAndCache error trying to add messages to cache:',
Errors.toLogFormat(error)
2019-09-26 19:56:31 +00:00
);
items.forEach(item => {
item.request.respond(500, 'Failed to cache message');
});
return;
2019-09-26 19:56:31 +00:00
}
await Promise.all(
decrypted.map(async ({ envelope, plaintext }) => {
try {
await this.queueDecryptedEnvelope(envelope, plaintext);
} catch (error) {
log.error(
2021-05-24 21:30:56 +00:00
'decryptAndCache error when processing decrypted envelope',
Errors.toLogFormat(error)
);
}
})
);
log.info('MessageReceiver.decryptAndCacheBatch fully processed');
this.maybeScheduleRetryTimeout();
}
private decryptAndCache(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
plaintext: Uint8Array,
request: IncomingWebSocketRequest
): void {
const { id } = envelope;
2021-07-09 19:36:10 +00:00
const data: UnprocessedType = {
id,
version: 2,
attempts: 1,
2021-07-09 19:36:10 +00:00
envelope: Bytes.toBase64(plaintext),
messageAgeSec: envelope.messageAgeSec,
receivedAtCounter: envelope.receivedAtCounter,
timestamp: envelope.timestamp,
urgent: envelope.urgent,
};
2021-05-24 21:30:56 +00:00
this.decryptAndCacheBatcher.add({
2019-09-26 19:56:31 +00:00
request,
envelope,
data,
});
}
private async cacheRemoveBatch(items: Array<string>): Promise<void> {
await this.storage.protocol.removeUnprocessed(items);
}
private removeFromCache(envelope: ProcessedEnvelope): void {
const { id } = envelope;
2019-09-26 19:56:31 +00:00
this.cacheRemoveBatcher.add(id);
}
private async queueDecryptedEnvelope(
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
plaintext: Uint8Array
): Promise<void> {
const id = getEnvelopeId(envelope);
log.info('queueing decrypted envelope', id);
2021-03-04 21:44:57 +00:00
const task = this.handleDecryptedEnvelope.bind(this, envelope, plaintext);
const taskWithTimeout = createTaskWithTimeout(
task,
2021-05-24 21:30:56 +00:00
`queueDecryptedEnvelope ${id}`
);
2021-03-04 21:44:57 +00:00
2021-07-09 19:36:10 +00:00
try {
await this.addToQueue(
taskWithTimeout,
'dispatchEvent',
TaskType.Decrypted
);
2021-07-09 19:36:10 +00:00
} catch (error) {
log.error(
`queueDecryptedEnvelope error handling envelope ${id}:`,
Errors.toLogFormat(error)
);
2021-07-09 19:36:10 +00:00
}
}
private async queueEncryptedEnvelope(
stores: LockedStores,
2022-07-28 16:35:29 +00:00
envelope: ProcessedEnvelope
2021-07-09 19:36:10 +00:00
): Promise<DecryptResult> {
let logId = getEnvelopeId(envelope);
2022-07-28 16:35:29 +00:00
log.info('queueing envelope', logId);
2021-03-04 21:44:57 +00:00
const task = async (): Promise<DecryptResult> => {
2022-07-28 16:35:29 +00:00
const { destinationUuid } = envelope;
const uuidKind = this.storage.user.getOurUuidKind(destinationUuid);
if (uuidKind === UUIDKind.Unknown) {
log.warn(
'MessageReceiver.decryptAndCacheBatch: ' +
`Rejecting envelope ${getEnvelopeId(envelope)}, ` +
`unknown uuid: ${destinationUuid}`
);
2022-08-15 21:53:33 +00:00
return { plaintext: undefined, envelope: undefined };
2022-07-28 16:35:29 +00:00
}
const unsealedEnvelope = await this.unsealEnvelope(
stores,
envelope,
uuidKind
);
// Dropped early
if (!unsealedEnvelope) {
2022-08-15 21:53:33 +00:00
return { plaintext: undefined, envelope: undefined };
}
logId = getEnvelopeId(unsealedEnvelope);
this.addToQueue(
async () => this.dispatchEvent(new EnvelopeEvent(unsealedEnvelope)),
'dispatchEvent',
TaskType.Decrypted
);
return this.decryptEnvelope(stores, unsealedEnvelope, uuidKind);
};
2021-03-04 21:44:57 +00:00
try {
return await this.addToQueue(
task,
`MessageReceiver: unseal and decrypt ${logId}`,
TaskType.Encrypted
);
} catch (error) {
2020-03-20 19:01:15 +00:00
const args = [
'queueEncryptedEnvelope error handling envelope',
logId,
':',
Errors.toLogFormat(error),
2020-03-20 19:01:15 +00:00
];
2021-09-22 00:58:03 +00:00
if (error instanceof WarnOnlyError) {
log.warn(...args);
2020-03-20 19:01:15 +00:00
} else {
log.error(...args);
2020-03-20 19:01:15 +00:00
}
throw error;
}
}
private async queueCachedEnvelope(
2021-05-24 21:30:56 +00:00
data: UnprocessedType,
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope
2021-05-24 21:30:56 +00:00
): Promise<void> {
this.decryptAndCacheBatcher.add({
request: {
respond(code, status) {
log.info(
2021-05-24 21:30:56 +00:00
'queueCachedEnvelope: fake response ' +
`with code ${code} and status ${status}`
);
},
},
2021-05-24 21:30:56 +00:00
envelope,
data,
});
}
// Called after `decryptEnvelope` decrypted the message.
private async handleDecryptedEnvelope(
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
plaintext: Uint8Array
): Promise<void> {
if (this.stoppingProcessing) {
return;
}
if (envelope.content) {
await this.innerHandleContentMessage(envelope, plaintext);
return;
}
this.removeFromCache(envelope);
2022-03-31 03:07:55 +00:00
throw new Error('Received message with no content');
}
private async unsealEnvelope(
stores: LockedStores,
envelope: ProcessedEnvelope,
uuidKind: UUIDKind
): Promise<UnsealedEnvelope | undefined> {
const logId = getEnvelopeId(envelope);
if (this.stoppingProcessing) {
log.warn(`MessageReceiver.unsealEnvelope(${logId}): dropping`);
throw new Error('Sealed envelope dropped due to stopping processing');
}
if (envelope.type !== Proto.Envelope.Type.UNIDENTIFIED_SENDER) {
2022-08-15 21:53:33 +00:00
strictAssert(
envelope.sourceUuid,
'Unsealed envelope must have source uuid'
);
return {
...envelope,
2022-08-15 21:53:33 +00:00
sourceUuid: envelope.sourceUuid,
cipherTextBytes: envelope.content,
cipherTextType: envelopeTypeToCiphertextType(envelope.type),
};
}
if (uuidKind === UUIDKind.PNI) {
log.warn(`MessageReceiver.unsealEnvelope(${logId}): dropping for PNI`);
return undefined;
}
strictAssert(uuidKind === UUIDKind.ACI, 'Sealed non-ACI envelope');
2022-03-31 03:07:55 +00:00
const ciphertext = envelope.content;
if (!ciphertext) {
this.removeFromCache(envelope);
2022-03-31 03:07:55 +00:00
throw new Error('Received message with no content');
}
log.info(`MessageReceiver.unsealEnvelope(${logId}): unidentified message`);
const messageContent = await sealedSenderDecryptToUsmc(
Buffer.from(ciphertext),
stores.identityKeyStore
);
// Here we take this sender information and attach it back to the envelope
// to make the rest of the app work properly.
const certificate = messageContent.senderCertificate();
const originalSource = envelope.source;
const originalSourceUuid = envelope.sourceUuid;
const newEnvelope: UnsealedEnvelope = {
...envelope,
cipherTextBytes: messageContent.contents(),
cipherTextType: messageContent.msgType(),
// Overwrite Envelope fields
source: dropNull(certificate.senderE164()),
sourceUuid: normalizeUuid(
certificate.senderUuid(),
'MessageReceiver.unsealEnvelope.UNIDENTIFIED_SENDER.sourceUuid'
),
sourceDevice: certificate.senderDeviceId(),
// UnsealedEnvelope-only fields
unidentifiedDeliveryReceived: !(originalSource || originalSourceUuid),
contentHint: messageContent.contentHint(),
groupId: messageContent.groupId()?.toString('base64'),
certificate,
unsealedContent: messageContent,
};
// This will throw if there's a problem
this.validateUnsealedEnvelope(newEnvelope);
return newEnvelope;
}
private async decryptEnvelope(
stores: LockedStores,
envelope: UnsealedEnvelope,
uuidKind: UUIDKind
2021-07-09 19:36:10 +00:00
): Promise<DecryptResult> {
const logId = getEnvelopeId(envelope);
if (this.stoppingProcessing) {
log.warn(`MessageReceiver.decryptEnvelope(${logId}): dropping unsealed`);
throw new Error('Unsealed envelope dropped due to stopping processing');
}
2021-07-09 19:36:10 +00:00
if (envelope.type === Proto.Envelope.Type.RECEIPT) {
2022-08-15 21:53:33 +00:00
strictAssert(
envelope.sourceUuid,
'Unsealed delivery receipt must have sourceUuid'
);
await this.onDeliveryReceipt(envelope);
2021-07-09 19:36:10 +00:00
return { plaintext: undefined, envelope };
}
let ciphertext: Uint8Array;
if (envelope.content) {
ciphertext = envelope.content;
} else {
this.removeFromCache(envelope);
strictAssert(
false,
'Contentless envelope should be handled by unsealEnvelope'
);
}
2022-03-31 03:07:55 +00:00
log.info(`MessageReceiver.decryptEnvelope(${logId})`);
const plaintext = await this.decrypt(
stores,
envelope,
ciphertext,
uuidKind
);
if (!plaintext) {
log.warn('MessageReceiver.decryptEnvelope: plaintext was falsey');
return { plaintext, envelope };
}
// Note: we need to process this as part of decryption, because we might need this
// sender key to decrypt the next message in the queue!
let isGroupV2 = false;
2022-08-15 21:53:33 +00:00
let inProgressMessageType = '';
try {
const content = Proto.Content.decode(plaintext);
isGroupV2 = Boolean(content.dataMessage?.groupV2);
if (
content.senderKeyDistributionMessage &&
Bytes.isNotEmpty(content.senderKeyDistributionMessage)
) {
2022-08-15 21:53:33 +00:00
inProgressMessageType = 'sender key distribution';
await this.handleSenderKeyDistributionMessage(
stores,
envelope,
content.senderKeyDistributionMessage
);
}
2022-07-28 16:35:29 +00:00
2022-08-15 21:53:33 +00:00
if (content.pniSignatureMessage) {
inProgressMessageType = 'pni signature';
await this.handlePniSignatureMessage(
envelope,
content.pniSignatureMessage
);
}
2022-07-28 16:35:29 +00:00
// Some sync messages have to be fully processed in the middle of
// decryption queue since subsequent envelopes use their key material.
const { syncMessage } = content;
if (syncMessage?.pniIdentity) {
2022-08-15 21:53:33 +00:00
inProgressMessageType = 'pni identity';
2022-07-28 16:35:29 +00:00
await this.handlePNIIdentity(envelope, syncMessage.pniIdentity);
return { plaintext: undefined, envelope };
}
if (syncMessage?.pniChangeNumber) {
2022-08-15 21:53:33 +00:00
inProgressMessageType = 'pni change number';
2022-07-28 16:35:29 +00:00
await this.handlePNIChangeNumber(envelope, syncMessage.pniChangeNumber);
return { plaintext: undefined, envelope };
}
2022-08-15 21:53:33 +00:00
inProgressMessageType = '';
} catch (error) {
log.error(
2022-08-15 21:53:33 +00:00
'MessageReceiver.decryptEnvelope: ' +
`Failed to process ${inProgressMessageType} ` +
`message: ${Errors.toLogFormat(error)}`
2021-07-09 19:36:10 +00:00
);
}
// We want to process GroupV2 updates, even from blocked users. We'll drop them later.
if (
!isGroupV2 &&
((envelope.source && this.isBlocked(envelope.source)) ||
(envelope.sourceUuid && this.isUuidBlocked(envelope.sourceUuid)))
) {
log.info(
'MessageReceiver.decryptEnvelope: Dropping non-GV2 message from blocked sender'
);
return { plaintext: undefined, envelope };
}
return { plaintext, envelope };
}
2021-07-09 19:36:10 +00:00
private validateUnsealedEnvelope(envelope: UnsealedEnvelope): void {
const { unsealedContent: messageContent, certificate } = envelope;
strictAssert(
messageContent !== undefined,
'Missing message content for sealed sender message'
);
strictAssert(
certificate !== undefined,
'Missing sender certificate for sealed sender message'
);
2021-07-09 19:36:10 +00:00
if (!envelope.serverTimestamp) {
2021-07-09 19:36:10 +00:00
throw new Error(
'MessageReceiver.decryptSealedSender: ' +
'Sealed sender message was missing serverTimestamp'
);
}
const serverCertificate = certificate.serverCertificate();
if (
!verifySignature(
2021-09-24 00:49:05 +00:00
this.serverTrustRoot,
serverCertificate.certificateData(),
serverCertificate.signature()
)
) {
throw new Error(
'MessageReceiver.validateUnsealedEnvelope: ' +
'Server certificate trust root validation failed'
);
}
if (
!verifySignature(
2021-09-24 00:49:05 +00:00
serverCertificate.key().serialize(),
certificate.certificate(),
certificate.signature()
)
) {
throw new Error(
'MessageReceiver.validateUnsealedEnvelope: ' +
'Server certificate server signature validation failed'
);
}
const logId = getEnvelopeId(envelope);
if (envelope.serverTimestamp > certificate.expiration()) {
throw new Error(
'MessageReceiver.validateUnsealedEnvelope: ' +
`Sender certificate is expired for envelope ${logId}, ` +
`serverTimestamp: ${envelope.serverTimestamp}, ` +
`expiration: ${certificate.expiration()}`
);
}
return undefined;
}
private async onDeliveryReceipt(envelope: ProcessedEnvelope): Promise<void> {
logUnexpectedUrgentValue(envelope, 'deliveryReceipt');
await this.dispatchAndWait(
new DeliveryEvent(
{
timestamp: envelope.timestamp,
envelopeTimestamp: envelope.serverTimestamp,
source: envelope.source,
sourceUuid: envelope.sourceUuid,
sourceDevice: envelope.sourceDevice,
2022-08-15 21:53:33 +00:00
wasSentEncrypted: false,
},
this.removeFromCache.bind(this, envelope)
)
);
}
private unpad(paddedPlaintext: Uint8Array): Uint8Array {
for (let i = paddedPlaintext.length - 1; i >= 0; i -= 1) {
if (paddedPlaintext[i] === 0x80) {
return new Uint8Array(paddedPlaintext.slice(0, i));
}
if (paddedPlaintext[i] !== 0x00) {
throw new Error('Invalid padding');
}
}
return paddedPlaintext;
}
private async decryptSealedSender(
{ senderKeyStore, sessionStore, identityKeyStore, zone }: LockedStores,
envelope: UnsealedEnvelope,
ciphertext: Uint8Array
): Promise<DecryptSealedSenderResult> {
const localE164 = this.storage.user.getNumber();
const { destinationUuid } = envelope;
const localDeviceId = parseIntOrThrow(
this.storage.user.getDeviceId(),
'MessageReceiver.decryptSealedSender: localDeviceId'
);
const logId = getEnvelopeId(envelope);
const { unsealedContent: messageContent, certificate } = envelope;
strictAssert(
messageContent !== undefined,
'Missing message content for sealed sender message'
);
strictAssert(
certificate !== undefined,
'Missing sender certificate for sealed sender message'
);
2021-07-09 19:36:10 +00:00
const unidentifiedSenderTypeEnum =
Proto.UnidentifiedSenderMessage.Message.Type;
if (
messageContent.msgType() === unidentifiedSenderTypeEnum.PLAINTEXT_CONTENT
) {
log.info(
`MessageReceiver.decryptSealedSender(${logId}): ` +
'unidentified message/plaintext contents'
2021-07-09 19:36:10 +00:00
);
const plaintextContent = PlaintextContent.deserialize(
messageContent.contents()
);
return {
plaintext: plaintextContent.body(),
2021-07-09 19:36:10 +00:00
};
}
if (
messageContent.msgType() === unidentifiedSenderTypeEnum.SENDERKEY_MESSAGE
) {
log.info(
`MessageReceiver.decryptSealedSender(${logId}): ` +
'unidentified message/sender key contents'
2021-07-09 19:36:10 +00:00
);
const sealedSenderIdentifier = certificate.senderUuid();
const sealedSenderSourceDevice = certificate.senderDeviceId();
const address = new QualifiedAddress(
destinationUuid,
Address.create(sealedSenderIdentifier, sealedSenderSourceDevice)
);
2021-07-09 19:36:10 +00:00
const plaintext = await this.storage.protocol.enqueueSenderKeyJob(
address,
() =>
groupDecrypt(
ProtocolAddress.new(
sealedSenderIdentifier,
sealedSenderSourceDevice
2021-07-09 19:36:10 +00:00
),
senderKeyStore,
messageContent.contents()
),
zone
);
return { plaintext };
2021-07-09 19:36:10 +00:00
}
log.info(
`MessageReceiver.decryptSealedSender(${logId}): ` +
'unidentified message/passing to sealedSenderDecryptMessage'
2021-07-09 19:36:10 +00:00
);
const preKeyStore = new PreKeys({ ourUuid: destinationUuid });
const signedPreKeyStore = new SignedPreKeys({ ourUuid: destinationUuid });
const sealedSenderIdentifier = envelope.sourceUuid;
strictAssert(
sealedSenderIdentifier !== undefined,
'Empty sealed sender identifier'
);
strictAssert(
envelope.sourceDevice !== undefined,
'Empty sealed sender device'
);
const address = new QualifiedAddress(
destinationUuid,
Address.create(sealedSenderIdentifier, envelope.sourceDevice)
);
const unsealedPlaintext = await this.storage.protocol.enqueueSessionJob(
address,
() =>
sealedSenderDecryptMessage(
Buffer.from(ciphertext),
PublicKey.deserialize(Buffer.from(this.serverTrustRoot)),
envelope.serverTimestamp,
localE164 || null,
destinationUuid.toString(),
localDeviceId,
sessionStore,
identityKeyStore,
preKeyStore,
signedPreKeyStore
),
zone
);
2021-07-09 19:36:10 +00:00
return { unsealedPlaintext };
2021-07-09 19:36:10 +00:00
}
private async innerDecrypt(
stores: LockedStores,
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
ciphertext: Uint8Array,
uuidKind: UUIDKind
): Promise<Uint8Array | undefined> {
2021-07-09 19:36:10 +00:00
const { sessionStore, identityKeyStore, zone } = stores;
const logId = getEnvelopeId(envelope);
2021-07-09 19:36:10 +00:00
const envelopeTypeEnum = Proto.Envelope.Type;
const identifier = envelope.sourceUuid;
2021-07-09 19:36:10 +00:00
const { sourceDevice } = envelope;
const { destinationUuid } = envelope;
const preKeyStore = new PreKeys({ ourUuid: destinationUuid });
const signedPreKeyStore = new SignedPreKeys({ ourUuid: destinationUuid });
strictAssert(identifier !== undefined, 'Empty identifier');
strictAssert(sourceDevice !== undefined, 'Empty source device');
const address = new QualifiedAddress(
destinationUuid,
Address.create(identifier, sourceDevice)
);
if (
uuidKind === UUIDKind.PNI &&
envelope.type !== envelopeTypeEnum.PREKEY_BUNDLE
) {
log.warn(
`MessageReceiver.innerDecrypt(${logId}): ` +
'non-PreKey envelope on PNI'
);
return undefined;
}
strictAssert(
uuidKind === UUIDKind.PNI || uuidKind === UUIDKind.ACI,
`Unsupported uuidKind: ${uuidKind}`
);
2021-05-28 19:11:19 +00:00
if (envelope.type === envelopeTypeEnum.PLAINTEXT_CONTENT) {
log.info(`decrypt/${logId}: plaintext message`);
2021-07-09 19:36:10 +00:00
const buffer = Buffer.from(ciphertext);
2021-05-28 19:11:19 +00:00
const plaintextContent = PlaintextContent.deserialize(buffer);
return this.unpad(plaintextContent.body());
2021-07-09 19:36:10 +00:00
}
if (envelope.type === envelopeTypeEnum.CIPHERTEXT) {
log.info(`decrypt/${logId}: ciphertext message`);
if (!identifier) {
throw new Error(
2021-07-09 19:36:10 +00:00
'MessageReceiver.innerDecrypt: No identifier for CIPHERTEXT message'
);
}
if (!sourceDevice) {
throw new Error(
2021-07-09 19:36:10 +00:00
'MessageReceiver.innerDecrypt: No sourceDevice for CIPHERTEXT message'
);
}
2021-07-09 19:36:10 +00:00
const signalMessage = SignalMessage.deserialize(Buffer.from(ciphertext));
const plaintext = await this.storage.protocol.enqueueSessionJob(
address,
async () =>
this.unpad(
await signalDecrypt(
signalMessage,
ProtocolAddress.new(identifier, sourceDevice),
sessionStore,
identityKeyStore
)
),
zone
);
return plaintext;
2021-07-09 19:36:10 +00:00
}
if (envelope.type === envelopeTypeEnum.PREKEY_BUNDLE) {
log.info(`decrypt/${logId}: prekey message`);
if (!identifier) {
throw new Error(
2021-07-09 19:36:10 +00:00
'MessageReceiver.innerDecrypt: No identifier for PREKEY_BUNDLE message'
);
}
if (!sourceDevice) {
throw new Error(
2021-07-09 19:36:10 +00:00
'MessageReceiver.innerDecrypt: No sourceDevice for PREKEY_BUNDLE message'
);
}
const preKeySignalMessage = PreKeySignalMessage.deserialize(
2021-07-09 19:36:10 +00:00
Buffer.from(ciphertext)
);
const plaintext = await this.storage.protocol.enqueueSessionJob(
address,
async () =>
this.unpad(
await signalDecryptPreKey(
preKeySignalMessage,
ProtocolAddress.new(identifier, sourceDevice),
sessionStore,
identityKeyStore,
preKeyStore,
signedPreKeyStore
)
),
zone
);
return plaintext;
2021-07-09 19:36:10 +00:00
}
if (envelope.type === envelopeTypeEnum.UNIDENTIFIED_SENDER) {
log.info(`decrypt/${logId}: unidentified message`);
const { plaintext, unsealedPlaintext } = await this.decryptSealedSender(
stores,
envelope,
ciphertext
);
2021-07-09 19:36:10 +00:00
if (plaintext) {
return this.unpad(plaintext);
2021-07-09 19:36:10 +00:00
}
2021-07-09 19:36:10 +00:00
if (unsealedPlaintext) {
const content = unsealedPlaintext.message();
if (!content) {
throw new Error(
2021-07-09 19:36:10 +00:00
'MessageReceiver.innerDecrypt: Content returned was falsey!'
);
}
// Return just the content because that matches the signature of the other
// decrypt methods used above.
return this.unpad(content);
2021-07-09 19:36:10 +00:00
}
2021-07-09 19:36:10 +00:00
throw new Error('Unexpected lack of plaintext from unidentified sender');
}
throw new Error('Unknown message type');
}
2021-02-18 16:40:26 +00:00
private async decrypt(
2021-07-09 19:36:10 +00:00
stores: LockedStores,
envelope: UnsealedEnvelope,
ciphertext: Uint8Array,
uuidKind: UUIDKind
): Promise<Uint8Array | undefined> {
2021-07-09 19:36:10 +00:00
try {
return await this.innerDecrypt(stores, envelope, ciphertext, uuidKind);
2021-07-09 19:36:10 +00:00
} catch (error) {
const uuid = envelope.sourceUuid;
const deviceId = envelope.sourceDevice;
// Job timed out, not a decryption error
2021-07-09 19:36:10 +00:00
if (
error?.name === 'TimeoutError' ||
error?.message?.includes?.('task did not complete in time')
2021-07-09 19:36:10 +00:00
) {
this.removeFromCache(envelope);
2021-02-18 16:40:26 +00:00
throw error;
2021-07-09 19:36:10 +00:00
}
// We don't do anything if it's just a duplicated message
if (error?.message?.includes?.('message with old counter')) {
this.removeFromCache(envelope);
throw error;
}
2021-07-09 19:36:10 +00:00
// We don't do a light session reset if it's an error with the sealed sender
// wrapper, since we don't trust the sender information.
if (error?.message?.includes?.('trust root validation failed')) {
this.removeFromCache(envelope);
2021-07-09 19:36:10 +00:00
throw error;
}
if (
(envelope.source && this.isBlocked(envelope.source)) ||
(envelope.sourceUuid && this.isUuidBlocked(envelope.sourceUuid))
) {
log.info(
'MessageReceiver.decrypt: Error from blocked sender; no further processing'
);
this.removeFromCache(envelope);
throw error;
}
2021-07-09 19:36:10 +00:00
if (uuid && deviceId) {
const { cipherTextBytes, cipherTextType } = envelope;
const event = new DecryptionErrorEvent(
{
cipherTextBytes,
cipherTextType,
contentHint: envelope.contentHint,
groupId: envelope.groupId,
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
senderDevice: deviceId,
senderUuid: uuid,
timestamp: envelope.timestamp,
},
() => this.removeFromCache(envelope)
);
2021-07-09 19:36:10 +00:00
// Avoid deadlocks by scheduling processing on decrypted queue
this.addToQueue(
async () => this.dispatchEvent(event),
'decrypted/dispatchEvent',
TaskType.Decrypted
);
2021-07-09 19:36:10 +00:00
} else {
const envelopeId = getEnvelopeId(envelope);
this.removeFromCache(envelope);
log.error(
2021-07-09 19:36:10 +00:00
`MessageReceiver.decrypt: Envelope ${envelopeId} missing uuid or deviceId`
);
}
throw error;
}
2021-02-18 16:40:26 +00:00
}
private async handleSentMessage(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
sentContainer: ProcessedSent
) {
log.info('MessageReceiver.handleSentMessage', getEnvelopeId(envelope));
logUnexpectedUrgentValue(envelope, 'sentSync');
const {
destination,
destinationUuid,
timestamp,
message: msg,
expirationStartTimestamp,
unidentifiedStatus,
isRecipientUpdate,
} = sentContainer;
if (!msg) {
throw new Error('MessageReceiver.handleSentMessage: message was falsey!');
}
let p: Promise<void> = Promise.resolve();
2021-07-09 19:36:10 +00:00
if (msg.flags && msg.flags & Proto.DataMessage.Flags.END_SESSION) {
2021-09-10 17:17:32 +00:00
if (destinationUuid) {
p = this.handleEndSession(envelope, new UUID(destinationUuid));
2021-09-10 17:17:32 +00:00
} else if (destination) {
const theirUuid = UUID.lookup(destination);
if (theirUuid) {
p = this.handleEndSession(envelope, theirUuid);
2021-09-10 17:17:32 +00:00
} else {
log.warn(`handleSentMessage: uuid not found for ${destination}`);
2021-09-10 17:17:32 +00:00
p = Promise.resolve();
}
} else {
throw new Error(
'MessageReceiver.handleSentMessage: Cannot end session with falsey destination'
);
}
}
2021-07-09 19:36:10 +00:00
await p;
const message = await this.processDecrypted(envelope, msg);
const groupId = this.getProcessedGroupId(message);
const isBlocked = groupId ? this.isGroupBlocked(groupId) : false;
const { source, sourceUuid } = envelope;
const ourE164 = this.storage.user.getNumber();
const ourUuid = this.storage.user.getCheckedUuid().toString();
2021-07-09 19:36:10 +00:00
const isMe =
(source && ourE164 && source === ourE164) ||
(sourceUuid && ourUuid && sourceUuid === ourUuid);
const isLeavingGroup = Boolean(
!message.groupV2 &&
message.group &&
message.group.type === Proto.GroupContext.Type.QUIT
);
2021-07-09 19:36:10 +00:00
if (groupId && isBlocked && !(isMe && isLeavingGroup)) {
log.warn(
`Message ${getEnvelopeId(envelope)} ignored; destined for blocked group`
2021-07-09 19:36:10 +00:00
);
this.removeFromCache(envelope);
return undefined;
}
2021-07-09 19:36:10 +00:00
const ev = new SentEvent(
{
destination: dropNull(destination),
2022-07-13 23:09:18 +00:00
destinationUuid:
dropNull(destinationUuid) || envelope.destinationUuid.toString(),
2022-03-23 20:49:27 +00:00
timestamp: timestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
serverTimestamp: envelope.serverTimestamp,
device: envelope.sourceDevice,
unidentifiedStatus,
message,
isRecipientUpdate: Boolean(isRecipientUpdate),
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
2022-03-23 20:49:27 +00:00
expirationStartTimestamp: expirationStartTimestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
},
this.removeFromCache.bind(this, envelope)
2018-05-02 16:51:22 +00:00
);
2021-07-09 19:36:10 +00:00
return this.dispatchAndWait(ev);
}
2022-03-04 21:14:52 +00:00
private async handleStoryMessage(
envelope: UnsealedEnvelope,
2022-07-01 00:52:03 +00:00
msg: Proto.IStoryMessage,
sentMessage?: ProcessedSent
): Promise<void> {
const logId = getEnvelopeId(envelope);
2022-03-04 21:14:52 +00:00
log.info('MessageReceiver.handleStoryMessage', logId);
const attachments: Array<ProcessedAttachment> = [];
if (window.Events.getHasStoriesDisabled()) {
log.info('MessageReceiver.handleStoryMessage: dropping', logId);
this.removeFromCache(envelope);
return;
}
2022-03-04 21:14:52 +00:00
if (msg.fileAttachment) {
const attachment = processAttachment(msg.fileAttachment);
attachments.push(attachment);
}
if (msg.textAttachment) {
const { text } = msg.textAttachment;
if (!text) {
throw new Error('Text attachments must have text!');
}
2022-06-17 00:48:57 +00:00
// TODO DESKTOP-3714 we should download the story link preview image
2022-04-06 01:18:07 +00:00
attachments.push({
size: text.length,
2022-08-02 19:31:55 +00:00
contentType: TEXT_ATTACHMENT,
2022-04-06 01:18:07 +00:00
textAttachment: msg.textAttachment,
blurHash: generateBlurHash(
(msg.textAttachment.color ||
msg.textAttachment.gradient?.startColor) ??
undefined
),
});
2022-03-04 21:14:52 +00:00
}
2022-04-15 00:08:46 +00:00
const groupV2 = msg.group ? processGroupV2Context(msg.group) : undefined;
if (groupV2 && this.isGroupBlocked(groupV2.id)) {
log.warn(
`MessageReceiver.handleStoryMessage: envelope ${getEnvelopeId(
2022-04-15 00:08:46 +00:00
envelope
)} ignored; destined for blocked group`
);
this.removeFromCache(envelope);
return;
}
const timeRemaining = Math.min(
Math.floor(envelope.timestamp + durations.DAY - Date.now()),
durations.DAY
);
if (timeRemaining <= 0) {
log.info(
2022-03-04 21:14:52 +00:00
'MessageReceiver.handleStoryMessage: story already expired',
logId
);
this.removeFromCache(envelope);
2022-03-04 21:14:52 +00:00
return;
}
const message: ProcessedDataMessage = {
2022-07-01 00:52:03 +00:00
attachments,
canReplyToStory: Boolean(msg.allowsReplies),
expireTimer: durations.DAY / 1000,
2022-07-01 00:52:03 +00:00
flags: 0,
groupV2,
isStory: true,
isViewOnce: false,
timestamp: envelope.timestamp,
};
2022-08-05 01:13:26 +00:00
if (sentMessage && message.groupV2) {
const ev = new SentEvent(
{
destinationUuid: envelope.destinationUuid.toString(),
isRecipientUpdate: Boolean(sentMessage.isRecipientUpdate),
message,
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
serverTimestamp: envelope.serverTimestamp,
timestamp: envelope.timestamp,
unidentifiedStatus: sentMessage.unidentifiedStatus,
},
this.removeFromCache.bind(this, envelope)
);
this.dispatchAndWait(ev);
return;
}
2022-07-01 00:52:03 +00:00
if (sentMessage) {
const { storyMessageRecipients } = sentMessage;
const recipients = storyMessageRecipients ?? [];
const isAllowedToReply = new Map<string, boolean>();
const distributionListToSentUuid = new Map<string, Set<string>>();
recipients.forEach(recipient => {
const { destinationUuid } = recipient;
if (!destinationUuid) {
return;
}
const normalizedDestinationUuid = normalizeUuid(
destinationUuid,
'handleStoryMessage.destinationUuid'
);
2022-07-01 00:52:03 +00:00
recipient.distributionListIds?.forEach(listId => {
const sentUuids: Set<string> =
distributionListToSentUuid.get(listId) || new Set();
sentUuids.add(normalizedDestinationUuid);
2022-07-01 00:52:03 +00:00
distributionListToSentUuid.set(listId, sentUuids);
});
isAllowedToReply.set(
normalizedDestinationUuid,
2022-07-13 23:09:18 +00:00
recipient.isAllowedToReply !== false
2022-07-01 00:52:03 +00:00
);
});
distributionListToSentUuid.forEach((sentToUuids, listId) => {
const ev = new SentEvent(
{
2022-07-06 19:06:20 +00:00
destinationUuid: envelope.destinationUuid.toString(),
2022-07-01 00:52:03 +00:00
timestamp: envelope.timestamp,
serverTimestamp: envelope.serverTimestamp,
unidentifiedStatus: Array.from(sentToUuids).map(
destinationUuid => ({
destinationUuid,
isAllowedToReplyToStory: isAllowedToReply.get(destinationUuid),
})
),
message,
isRecipientUpdate: Boolean(sentMessage.isRecipientUpdate),
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
storyDistributionListId: normalizeUuid(
listId,
'storyDistributionListId'
),
2022-07-01 00:52:03 +00:00
},
this.removeFromCache.bind(this, envelope)
);
this.dispatchAndWait(ev);
});
return;
}
2022-03-04 21:14:52 +00:00
const ev = new MessageEvent(
{
source: envelope.source,
sourceUuid: envelope.sourceUuid,
sourceDevice: envelope.sourceDevice,
2022-08-15 21:53:33 +00:00
destinationUuid: envelope.destinationUuid.toString(),
2022-03-04 21:14:52 +00:00
timestamp: envelope.timestamp,
serverGuid: envelope.serverGuid,
serverTimestamp: envelope.serverTimestamp,
unidentifiedDeliveryReceived: Boolean(
envelope.unidentifiedDeliveryReceived
),
2022-07-01 00:52:03 +00:00
message,
2022-03-04 21:14:52 +00:00
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
},
this.removeFromCache.bind(this, envelope)
);
return this.dispatchAndWait(ev);
}
private async handleDataMessage(
envelope: UnsealedEnvelope,
msg: Proto.IDataMessage
): Promise<void> {
const logId = getEnvelopeId(envelope);
2022-03-04 21:14:52 +00:00
log.info('MessageReceiver.handleDataMessage', logId);
const isStoriesEnabled =
isEnabled('desktop.stories') || isEnabled('desktop.internalUser');
if (!isStoriesEnabled && msg.storyContext) {
logUnexpectedUrgentValue(envelope, 'story');
log.info(
`MessageReceiver.handleDataMessage/${logId}: Dropping incoming dataMessage with storyContext field`
);
this.removeFromCache(envelope);
return undefined;
}
let p: Promise<void> = Promise.resolve();
const destination = envelope.sourceUuid;
if (!destination) {
throw new Error(
'MessageReceiver.handleDataMessage: source and sourceUuid were falsey'
);
}
2020-11-20 17:30:45 +00:00
if (this.isInvalidGroupData(msg, envelope)) {
this.removeFromCache(envelope);
return undefined;
}
2021-07-09 19:36:10 +00:00
await this.checkGroupV1Data(msg);
2020-09-09 02:25:05 +00:00
2021-07-09 19:36:10 +00:00
if (msg.flags && msg.flags & Proto.DataMessage.Flags.END_SESSION) {
p = this.handleEndSession(envelope, new UUID(destination));
}
2020-05-27 21:37:06 +00:00
2021-07-09 19:36:10 +00:00
if (msg.flags && msg.flags & Proto.DataMessage.Flags.PROFILE_KEY_UPDATE) {
strictAssert(
2022-09-14 16:40:50 +00:00
msg.profileKey != null && msg.profileKey.length > 0,
'PROFILE_KEY_UPDATE without profileKey'
);
2021-07-09 19:36:10 +00:00
logUnexpectedUrgentValue(envelope, 'profileKeyUpdate');
2021-07-09 19:36:10 +00:00
const ev = new ProfileKeyUpdateEvent(
{
source: envelope.source,
sourceUuid: envelope.sourceUuid,
profileKey: Bytes.toBase64(msg.profileKey),
},
this.removeFromCache.bind(this, envelope)
);
2020-05-27 21:37:06 +00:00
return this.dispatchAndWait(ev);
}
2021-07-09 19:36:10 +00:00
await p;
let type: SendTypesType = 'message';
if (msg.storyContext) {
type = 'story';
} else if (msg.body) {
type = 'message';
} else if (msg.reaction) {
type = 'reaction';
} else if (msg.delete) {
type = 'deleteForEveryone';
} else if (
msg.flags &&
msg.flags & Proto.DataMessage.Flags.EXPIRATION_TIMER_UPDATE
) {
type = 'expirationTimerUpdate';
} else if (msg.group) {
type = 'legacyGroupChange';
}
// Note: other data messages without any of these attributes will fall into the
// 'message' bucket - like stickers, gift badges, etc.
logUnexpectedUrgentValue(envelope, type);
2021-07-09 19:36:10 +00:00
const message = await this.processDecrypted(envelope, msg);
const groupId = this.getProcessedGroupId(message);
const isBlocked = groupId ? this.isGroupBlocked(groupId) : false;
const { source, sourceUuid } = envelope;
const ourE164 = this.storage.user.getNumber();
const ourUuid = this.storage.user.getCheckedUuid().toString();
2021-07-09 19:36:10 +00:00
const isMe =
(source && ourE164 && source === ourE164) ||
(sourceUuid && ourUuid && sourceUuid === ourUuid);
const isLeavingGroup = Boolean(
!message.groupV2 &&
message.group &&
message.group.type === Proto.GroupContext.Type.QUIT
);
2020-05-27 21:37:06 +00:00
2021-07-09 19:36:10 +00:00
if (groupId && isBlocked && !(isMe && isLeavingGroup)) {
log.warn(
`Message ${getEnvelopeId(envelope)} ignored; destined for blocked group`
2021-07-09 19:36:10 +00:00
);
this.removeFromCache(envelope);
return undefined;
}
2021-07-09 19:36:10 +00:00
const ev = new MessageEvent(
{
source: envelope.source,
sourceUuid: envelope.sourceUuid,
sourceDevice: envelope.sourceDevice,
2022-08-15 21:53:33 +00:00
destinationUuid: envelope.destinationUuid.toString(),
2021-07-09 19:36:10 +00:00
timestamp: envelope.timestamp,
serverGuid: envelope.serverGuid,
serverTimestamp: envelope.serverTimestamp,
unidentifiedDeliveryReceived: Boolean(
envelope.unidentifiedDeliveryReceived
),
message,
receivedAtCounter: envelope.receivedAtCounter,
receivedAtDate: envelope.receivedAtDate,
},
this.removeFromCache.bind(this, envelope)
2018-05-02 16:51:22 +00:00
);
2021-07-09 19:36:10 +00:00
return this.dispatchAndWait(ev);
}
private async maybeUpdateTimestamp(
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope
): Promise<UnsealedEnvelope> {
const { retryPlaceholders } = window.Signal.Services;
if (!retryPlaceholders) {
log.warn('maybeUpdateTimestamp: retry placeholders not available!');
return envelope;
}
const { timestamp } = envelope;
const identifier = envelope.groupId || envelope.sourceUuid;
const conversation = window.ConversationController.get(identifier);
try {
if (!conversation) {
const idForLogging = envelope.groupId
? `groupv2(${envelope.groupId})`
: envelope.sourceUuid;
log.info(
`maybeUpdateTimestamp/${timestamp}: No conversation found for identifier ${idForLogging}`
);
return envelope;
}
const logId = `${conversation.idForLogging()}/${timestamp}`;
const item = await retryPlaceholders.findByMessageAndRemove(
conversation.id,
timestamp
);
if (item && item.wasOpened) {
log.info(
`maybeUpdateTimestamp/${logId}: found retry placeholder, but conversation was opened. No updates made.`
);
} else if (item) {
log.info(
`maybeUpdateTimestamp/${logId}: found retry placeholder. Updating receivedAtCounter/receivedAtDate`
);
return {
...envelope,
receivedAtCounter: item.receivedAtCounter,
receivedAtDate: item.receivedAt,
};
}
} catch (error) {
log.error(
`maybeUpdateTimestamp/${timestamp}: Failed to process message: ${Errors.toLogFormat(
error
)}`
);
}
return envelope;
}
private async innerHandleContentMessage(
2022-08-15 21:53:33 +00:00
incomingEnvelope: UnsealedEnvelope,
plaintext: Uint8Array
): Promise<void> {
const content = Proto.Content.decode(plaintext);
const envelope = await this.maybeUpdateTimestamp(incomingEnvelope);
2021-05-28 19:11:19 +00:00
if (
content.decryptionErrorMessage &&
2021-07-09 19:36:10 +00:00
Bytes.isNotEmpty(content.decryptionErrorMessage)
2021-05-28 19:11:19 +00:00
) {
await this.handleDecryptionError(
envelope,
content.decryptionErrorMessage
);
return;
}
if (content.syncMessage) {
2021-07-09 19:36:10 +00:00
await this.handleSyncMessage(
envelope,
processSyncMessage(content.syncMessage)
);
return;
}
if (content.dataMessage) {
await this.handleDataMessage(envelope, content.dataMessage);
return;
}
if (content.nullMessage) {
await this.handleNullMessage(envelope);
return;
}
if (content.callingMessage) {
await this.handleCallingMessage(envelope, content.callingMessage);
return;
}
if (content.receiptMessage) {
await this.handleReceiptMessage(envelope, content.receiptMessage);
return;
}
if (content.typingMessage) {
await this.handleTypingMessage(envelope, content.typingMessage);
return;
}
const isStoriesEnabled =
isEnabled('desktop.stories') || isEnabled('desktop.internalUser');
if (content.storyMessage) {
if (isStoriesEnabled) {
await this.handleStoryMessage(envelope, content.storyMessage);
return;
}
const logId = getEnvelopeId(envelope);
log.info(
`innerHandleContentMessage/${logId}: Dropping incoming message with storyMessage field`
);
this.removeFromCache(envelope);
return;
}
this.removeFromCache(envelope);
2021-07-09 19:36:10 +00:00
if (Bytes.isEmpty(content.senderKeyDistributionMessage)) {
throw new Error('Unsupported content message');
}
}
private async handleDecryptionError(
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
decryptionError: Uint8Array
2021-05-28 19:11:19 +00:00
) {
const logId = getEnvelopeId(envelope);
log.info(`handleDecryptionError: ${logId}`);
2021-05-28 19:11:19 +00:00
logUnexpectedUrgentValue(envelope, 'retryRequest');
2021-07-09 19:36:10 +00:00
const buffer = Buffer.from(decryptionError);
2021-05-28 19:11:19 +00:00
const request = DecryptionErrorMessage.deserialize(buffer);
const { sourceUuid, sourceDevice } = envelope;
if (!sourceUuid || !sourceDevice) {
log.error(`handleDecryptionError/${logId}: Missing uuid or device!`);
this.removeFromCache(envelope);
2021-05-28 19:11:19 +00:00
return;
}
const event = new RetryRequestEvent(
{
groupId: envelope.groupId,
requesterDevice: sourceDevice,
requesterUuid: sourceUuid,
ratchetKey: request.ratchetKey(),
senderDevice: request.deviceId(),
sentAt: request.timestamp(),
},
() => this.removeFromCache(envelope)
);
await this.dispatchEvent(event);
2021-05-28 19:11:19 +00:00
}
private async handleSenderKeyDistributionMessage(
stores: LockedStores,
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
distributionMessage: Uint8Array
): Promise<void> {
const envelopeId = getEnvelopeId(envelope);
log.info(`handleSenderKeyDistributionMessage/${envelopeId}`);
logUnexpectedUrgentValue(envelope, 'senderKeyDistributionMessage');
// Note: we don't call removeFromCache here because this message can be combined
// with a dataMessage, for example. That processing will dictate cache removal.
const identifier = envelope.sourceUuid;
const { sourceDevice } = envelope;
if (!isNumber(sourceDevice)) {
throw new Error(
`handleSenderKeyDistributionMessage: Missing sourceDevice for envelope ${envelopeId}`
);
}
const sender = ProtocolAddress.new(identifier, sourceDevice);
2021-11-11 22:43:05 +00:00
const senderKeyDistributionMessage =
SenderKeyDistributionMessage.deserialize(
Buffer.from(distributionMessage)
);
const { destinationUuid } = envelope;
const address = new QualifiedAddress(
destinationUuid,
Address.create(identifier, sourceDevice)
);
await this.storage.protocol.enqueueSenderKeyJob(
address,
() =>
processSenderKeyDistributionMessage(
sender,
senderKeyDistributionMessage,
stores.senderKeyStore
),
stores.zone
);
}
2022-08-15 21:53:33 +00:00
private async handlePniSignatureMessage(
envelope: UnsealedEnvelope,
pniSignatureMessage: Proto.IPniSignatureMessage
): Promise<void> {
const envelopeId = getEnvelopeId(envelope);
const logId = `handlePniSignatureMessage/${envelopeId}`;
log.info(logId);
// Note: we don't call removeFromCache here because this message can be combined
// with a dataMessage, for example. That processing will dictate cache removal.
const aci = envelope.sourceUuid;
const { pni: pniBytes, signature } = pniSignatureMessage;
strictAssert(Bytes.isNotEmpty(pniBytes), `${logId}: missing PNI bytes`);
const pni = bytesToUuid(pniBytes);
strictAssert(pni, `${logId}: missing PNI`);
strictAssert(Bytes.isNotEmpty(signature), `${logId}: empty signature`);
const isValid = await this.storage.protocol.verifyAlternateIdentity({
aci: new UUID(aci),
pni: new UUID(pni),
signature,
});
if (isValid) {
log.info(`${logId}: merging pni=${pni} aci=${aci}`);
window.ConversationController.maybeMergeContacts({
pni,
aci,
e164: window.ConversationController.get(pni)?.get('e164'),
reason: logId,
});
}
}
private async handleCallingMessage(
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
callingMessage: Proto.ICallingMessage
): Promise<void> {
logUnexpectedUrgentValue(envelope, 'callingMessage');
this.removeFromCache(envelope);
2020-06-04 18:16:19 +00:00
await window.Signal.Services.calling.handleCallingMessage(
envelope,
callingMessage
);
}
private async handleReceiptMessage(
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
receiptMessage: Proto.IReceiptMessage
): Promise<void> {
2021-07-09 19:36:10 +00:00
strictAssert(receiptMessage.timestamp, 'Receipt message without timestamp');
let EventClass: typeof DeliveryEvent | typeof ReadEvent | typeof ViewEvent;
let type: SendTypesType;
switch (receiptMessage.type) {
case Proto.ReceiptMessage.Type.DELIVERY:
EventClass = DeliveryEvent;
type = 'deliveryReceipt';
break;
case Proto.ReceiptMessage.Type.READ:
EventClass = ReadEvent;
type = 'readReceipt';
break;
case Proto.ReceiptMessage.Type.VIEWED:
EventClass = ViewEvent;
type = 'viewedReceipt';
break;
default:
// This can happen if we get a receipt type we don't know about yet, which
// is totally fine.
return;
}
logUnexpectedUrgentValue(envelope, type);
await Promise.all(
receiptMessage.timestamp.map(async rawTimestamp => {
const ev = new EventClass(
2021-07-09 19:36:10 +00:00
{
2022-03-23 20:49:27 +00:00
timestamp: rawTimestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
envelopeTimestamp: envelope.timestamp,
source: envelope.source,
sourceUuid: envelope.sourceUuid,
sourceDevice: envelope.sourceDevice,
2022-08-15 21:53:33 +00:00
wasSentEncrypted: true,
2021-07-09 19:36:10 +00:00
},
this.removeFromCache.bind(this, envelope)
);
await this.dispatchAndWait(ev);
})
);
}
private async handleTypingMessage(
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
typingMessage: Proto.ITypingMessage
): Promise<void> {
2018-11-14 19:10:32 +00:00
this.removeFromCache(envelope);
logUnexpectedUrgentValue(envelope, 'typing');
2018-11-14 19:10:32 +00:00
if (envelope.timestamp && typingMessage.timestamp) {
2021-07-09 19:36:10 +00:00
const envelopeTimestamp = envelope.timestamp;
2022-03-23 20:49:27 +00:00
const typingTimestamp = typingMessage.timestamp?.toNumber();
2018-11-14 19:10:32 +00:00
if (typingTimestamp !== envelopeTimestamp) {
log.warn(
2018-11-14 19:10:32 +00:00
`Typing message envelope timestamp (${envelopeTimestamp}) did not match typing timestamp (${typingTimestamp})`
);
return;
2018-11-14 19:10:32 +00:00
}
}
2021-07-09 19:36:10 +00:00
strictAssert(
envelope.sourceDevice !== undefined,
'TypingMessage requires sourceDevice in the envelope'
);
2018-11-14 19:10:32 +00:00
2021-07-09 19:36:10 +00:00
const { groupId, timestamp, action } = typingMessage;
2020-11-20 17:30:45 +00:00
2021-07-09 19:36:10 +00:00
let groupIdString: string | undefined;
let groupV2IdString: string | undefined;
if (groupId && groupId.byteLength > 0) {
if (groupId.byteLength === GROUPV1_ID_LENGTH) {
groupIdString = Bytes.toBinary(groupId);
2021-09-24 00:49:05 +00:00
groupV2IdString = this.deriveGroupV2FromV1(groupId);
2021-07-09 19:36:10 +00:00
} else if (groupId.byteLength === GROUPV2_ID_LENGTH) {
groupV2IdString = Bytes.toBase64(groupId);
2020-11-20 17:30:45 +00:00
} else {
log.error('handleTypingMessage: Received invalid groupId value');
2020-11-20 17:30:45 +00:00
}
}
2021-07-09 19:36:10 +00:00
await this.dispatchEvent(
new TypingEvent({
sender: envelope.source,
senderUuid: envelope.sourceUuid,
senderDevice: envelope.sourceDevice,
typing: {
typingMessage,
2022-03-23 20:49:27 +00:00
timestamp: timestamp?.toNumber() ?? Date.now(),
2021-07-09 19:36:10 +00:00
started: action === Proto.TypingMessage.Action.STARTED,
stopped: action === Proto.TypingMessage.Action.STOPPED,
groupId: groupIdString,
groupV2Id: groupV2IdString,
},
})
);
}
2022-08-15 21:53:33 +00:00
private handleNullMessage(envelope: UnsealedEnvelope): void {
log.info('MessageReceiver.handleNullMessage', getEnvelopeId(envelope));
logUnexpectedUrgentValue(envelope, 'nullMessage');
this.removeFromCache(envelope);
}
private isInvalidGroupData(
2021-07-09 19:36:10 +00:00
message: Proto.IDataMessage,
envelope: ProcessedEnvelope
2020-11-20 17:30:45 +00:00
): boolean {
const { group, groupV2 } = message;
if (group) {
2021-07-09 19:36:10 +00:00
const { id } = group;
strictAssert(id, 'Group data has no id');
2020-11-20 17:30:45 +00:00
const isInvalid = id.byteLength !== GROUPV1_ID_LENGTH;
if (isInvalid) {
log.info(
2020-11-20 17:30:45 +00:00
'isInvalidGroupData: invalid GroupV1 message from',
getEnvelopeId(envelope)
2020-11-20 17:30:45 +00:00
);
}
return isInvalid;
}
if (groupV2) {
2021-07-09 19:36:10 +00:00
const { masterKey } = groupV2;
strictAssert(masterKey, 'Group v2 data has no masterKey');
2020-11-20 17:30:45 +00:00
const isInvalid = masterKey.byteLength !== MASTER_KEY_LENGTH;
if (isInvalid) {
log.info(
2020-11-20 17:30:45 +00:00
'isInvalidGroupData: invalid GroupV2 message from',
getEnvelopeId(envelope)
2020-11-20 17:30:45 +00:00
);
}
return isInvalid;
}
return false;
}
2021-09-24 00:49:05 +00:00
private deriveGroupV2FromV1(groupId: Uint8Array): string {
2020-11-20 17:30:45 +00:00
if (groupId.byteLength !== GROUPV1_ID_LENGTH) {
throw new Error(
`deriveGroupV2FromV1: had id with wrong byteLength: ${groupId.byteLength}`
);
}
2021-09-24 00:49:05 +00:00
const masterKey = deriveMasterKeyFromGroupV1(groupId);
const data = deriveGroupFields(masterKey);
2020-11-20 17:30:45 +00:00
2021-06-22 14:46:42 +00:00
return Bytes.toBase64(data.id);
2020-11-20 17:30:45 +00:00
}
private async checkGroupV1Data(
message: Readonly<Proto.IDataMessage>
): Promise<void> {
2020-11-20 17:30:45 +00:00
const { group } = message;
if (!group) {
return;
}
if (!group.id) {
throw new Error('deriveGroupV1Data: had falsey id');
}
2021-07-09 19:36:10 +00:00
const { id } = group;
2020-11-20 17:30:45 +00:00
if (id.byteLength !== GROUPV1_ID_LENGTH) {
throw new Error(
`deriveGroupV1Data: had id with wrong byteLength: ${id.byteLength}`
);
}
}
private getProcessedGroupId(
message: ProcessedDataMessage
): string | undefined {
2021-07-09 19:36:10 +00:00
if (message.groupV2) {
return message.groupV2.id;
2020-09-09 02:25:05 +00:00
}
2021-07-09 19:36:10 +00:00
if (message.group && message.group.id) {
return message.group.id;
2020-09-09 02:25:05 +00:00
}
2021-07-09 19:36:10 +00:00
return undefined;
2020-09-09 02:25:05 +00:00
}
private getGroupId(message: Proto.IDataMessage): string | undefined {
2020-09-09 02:25:05 +00:00
if (message.groupV2) {
2021-07-09 19:36:10 +00:00
strictAssert(message.groupV2.masterKey, 'Missing groupV2.masterKey');
const { id } = deriveGroupFields(message.groupV2.masterKey);
return Bytes.toBase64(id);
2020-09-09 02:25:05 +00:00
}
2021-07-09 19:36:10 +00:00
if (message.group && message.group.id) {
return Bytes.toBinary(message.group.id);
2020-09-09 02:25:05 +00:00
}
2021-07-09 19:36:10 +00:00
return undefined;
2020-09-09 02:25:05 +00:00
}
private getDestination(sentMessage: Proto.SyncMessage.ISent) {
2020-09-09 02:25:05 +00:00
if (sentMessage.message && sentMessage.message.groupV2) {
2021-07-09 19:36:10 +00:00
return `groupv2(${this.getGroupId(sentMessage.message)})`;
}
if (sentMessage.message && sentMessage.message.group) {
2021-07-09 19:36:10 +00:00
strictAssert(sentMessage.message.group.id, 'group without id');
return `group(${this.getGroupId(sentMessage.message)})`;
2020-09-09 02:25:05 +00:00
}
return sentMessage.destination || sentMessage.destinationUuid;
2020-09-09 02:25:05 +00:00
}
private async handleSyncMessage(
2022-08-15 21:53:33 +00:00
envelope: UnsealedEnvelope,
2021-07-09 19:36:10 +00:00
syncMessage: ProcessedSyncMessage
): Promise<void> {
const ourNumber = this.storage.user.getNumber();
const ourUuid = this.storage.user.getCheckedUuid();
const fromSelfSource = envelope.source && envelope.source === ourNumber;
const fromSelfSourceUuid =
envelope.sourceUuid && envelope.sourceUuid === ourUuid.toString();
if (!fromSelfSource && !fromSelfSourceUuid) {
throw new Error('Received sync message from another number');
}
const ourDeviceId = this.storage.user.getDeviceId();
// eslint-disable-next-line eqeqeq
if (envelope.sourceDevice == ourDeviceId) {
throw new Error('Received sync message from our own device');
}
2022-07-28 16:35:29 +00:00
if (syncMessage.pniIdentity) {
return;
}
if (syncMessage.sent) {
const sentMessage = syncMessage.sent;
2022-07-01 00:52:03 +00:00
if (sentMessage.storyMessage) {
this.handleStoryMessage(
envelope,
sentMessage.storyMessage,
sentMessage
);
return;
}
2022-07-13 23:09:18 +00:00
if (sentMessage.storyMessageRecipients && sentMessage.isRecipientUpdate) {
if (window.Events.getHasStoriesDisabled()) {
log.info(
'MessageReceiver.handleSyncMessage: dropping story recipients update'
);
this.removeFromCache(envelope);
return;
}
2022-07-29 23:01:33 +00:00
log.info(
'MessageReceiver.handleSyncMessage: handling storyMessageRecipients isRecipientUpdate sync message',
getEnvelopeId(envelope)
);
2022-07-13 23:09:18 +00:00
const ev = new StoryRecipientUpdateEvent(
{
destinationUuid: envelope.destinationUuid.toString(),
timestamp: envelope.timestamp,
storyMessageRecipients: sentMessage.storyMessageRecipients,
},
this.removeFromCache.bind(this, envelope)
);
return this.dispatchAndWait(ev);
}
if (!sentMessage || !sentMessage.message) {
throw new Error(
'MessageReceiver.handleSyncMessage: sync sent message was missing message'
);
}
2020-09-09 02:25:05 +00:00
2020-11-20 17:30:45 +00:00
if (this.isInvalidGroupData(sentMessage.message, envelope)) {
this.removeFromCache(envelope);
2022-07-28 16:35:29 +00:00
return;
2020-11-20 17:30:45 +00:00
}
2021-07-09 19:36:10 +00:00
await this.checkGroupV1Data(sentMessage.message);
strictAssert(sentMessage.timestamp, 'sent message without timestamp');
log.info(
'sent message to',
2020-09-09 02:25:05 +00:00
this.getDestination(sentMessage),
2022-03-23 20:49:27 +00:00
sentMessage.timestamp?.toNumber(),
'from',
getEnvelopeId(envelope)
);
return this.handleSentMessage(envelope, sentMessage);
}
if (syncMessage.contacts) {
// Note: this method will download attachment and thus might block
// message processing, but we would like to fully process contact sync
// before moving on since it updates conversation state.
return this.handleContacts(envelope, syncMessage.contacts);
}
if (syncMessage.groups) {
this.handleGroups(envelope, syncMessage.groups);
2022-07-28 16:35:29 +00:00
return;
}
if (syncMessage.blocked) {
return this.handleBlocked(envelope, syncMessage.blocked);
}
if (syncMessage.request) {
log.info('Got SyncMessage Request');
this.removeFromCache(envelope);
2022-07-28 16:35:29 +00:00
return;
}
if (syncMessage.read && syncMessage.read.length) {
return this.handleRead(envelope, syncMessage.read);
}
if (syncMessage.verified) {
log.info('Got verified sync message, dropping');
this.removeFromCache(envelope);
2022-07-28 16:35:29 +00:00
return;
}
if (syncMessage.configuration) {
return this.handleConfiguration(envelope, syncMessage.configuration);
}
if (
2019-06-26 19:33:13 +00:00
syncMessage.stickerPackOperation &&
syncMessage.stickerPackOperation.length > 0
) {
return this.handleStickerPackOperation(
envelope,
syncMessage.stickerPackOperation
);
}
if (syncMessage.viewOnceOpen) {
2019-08-05 20:53:15 +00:00
return this.handleViewOnceOpen(envelope, syncMessage.viewOnceOpen);
}
if (syncMessage.messageRequestResponse) {
2020-05-27 21:37:06 +00:00
return this.handleMessageRequestResponse(
envelope,
syncMessage.messageRequestResponse
);
}
if (syncMessage.fetchLatest) {
return this.handleFetchLatest(envelope, syncMessage.fetchLatest);
}
if (syncMessage.keys) {
return this.handleKeys(envelope, syncMessage.keys);
}
if (syncMessage.viewed && syncMessage.viewed.length) {
return this.handleViewed(envelope, syncMessage.viewed);
}
this.removeFromCache(envelope);
log.warn(
`handleSyncMessage/${getEnvelopeId(envelope)}: Got empty SyncMessage`
);
}
private async handleConfiguration(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
configuration: Proto.SyncMessage.IConfiguration
): Promise<void> {
log.info('got configuration sync message');
logUnexpectedUrgentValue(envelope, 'configurationSync');
2021-07-09 19:36:10 +00:00
const ev = new ConfigurationEvent(
configuration,
this.removeFromCache.bind(this, envelope)
);
return this.dispatchAndWait(ev);
}
private async handleViewOnceOpen(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
sync: Proto.SyncMessage.IViewOnceOpen
): Promise<void> {
log.info('got view once open sync message');
2019-06-26 19:33:13 +00:00
logUnexpectedUrgentValue(envelope, 'viewOnceSync');
const ev = new ViewOnceOpenSyncEvent(
2021-07-09 19:36:10 +00:00
{
source: dropNull(sync.sender),
sourceUuid: sync.senderUuid
? normalizeUuid(sync.senderUuid, 'handleViewOnceOpen.senderUuid')
: undefined,
2022-03-23 20:49:27 +00:00
timestamp: sync.timestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
},
this.removeFromCache.bind(this, envelope)
);
2019-06-26 19:33:13 +00:00
return this.dispatchAndWait(ev);
}
private async handleMessageRequestResponse(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
sync: Proto.SyncMessage.IMessageRequestResponse
): Promise<void> {
log.info('got message request response sync message');
2020-05-27 21:37:06 +00:00
logUnexpectedUrgentValue(envelope, 'messageRequestSync');
2021-07-09 19:36:10 +00:00
const { groupId } = sync;
let groupIdString: string | undefined;
let groupV2IdString: string | undefined;
if (groupId && groupId.byteLength > 0) {
if (groupId.byteLength === GROUPV1_ID_LENGTH) {
groupIdString = Bytes.toBinary(groupId);
2021-09-24 00:49:05 +00:00
groupV2IdString = this.deriveGroupV2FromV1(groupId);
2021-07-09 19:36:10 +00:00
} else if (groupId.byteLength === GROUPV2_ID_LENGTH) {
groupV2IdString = Bytes.toBase64(groupId);
2020-11-20 17:30:45 +00:00
} else {
this.removeFromCache(envelope);
log.error('Received message request with invalid groupId');
2020-11-20 17:30:45 +00:00
return undefined;
}
}
2021-07-09 19:36:10 +00:00
const ev = new MessageRequestResponseEvent(
{
threadE164: dropNull(sync.threadE164),
threadUuid: sync.threadUuid
? normalizeUuid(
sync.threadUuid,
'handleMessageRequestResponse.threadUuid'
)
: undefined,
messageRequestResponseType: sync.type,
groupId: groupIdString,
groupV2Id: groupV2IdString,
},
this.removeFromCache.bind(this, envelope)
2020-05-27 21:37:06 +00:00
);
2020-11-20 17:30:45 +00:00
return this.dispatchAndWait(ev);
}
private async handleFetchLatest(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
sync: Proto.SyncMessage.IFetchLatest
): Promise<void> {
log.info('got fetch latest sync message');
logUnexpectedUrgentValue(envelope, 'fetchLatestManifestSync');
2021-07-09 19:36:10 +00:00
const ev = new FetchLatestEvent(
sync.type,
this.removeFromCache.bind(this, envelope)
);
return this.dispatchAndWait(ev);
}
private async handleKeys(
envelope: ProcessedEnvelope,
sync: Proto.SyncMessage.IKeys
): Promise<void> {
log.info('got keys sync message');
logUnexpectedUrgentValue(envelope, 'keySync');
if (!sync.storageService) {
return undefined;
}
2021-07-09 19:36:10 +00:00
const ev = new KeysEvent(
2021-09-24 00:49:05 +00:00
sync.storageService,
2021-07-09 19:36:10 +00:00
this.removeFromCache.bind(this, envelope)
);
2020-05-27 21:37:06 +00:00
return this.dispatchAndWait(ev);
}
2022-07-28 16:35:29 +00:00
// Runs on TaskType.Encrypted queue
private async handlePNIIdentity(
envelope: ProcessedEnvelope,
{ publicKey, privateKey }: Proto.SyncMessage.IPniIdentity
): Promise<void> {
log.info('MessageReceiver: got pni identity sync message');
logUnexpectedUrgentValue(envelope, 'pniIdentitySync');
if (!publicKey || !privateKey) {
log.warn('MessageReceiver: empty pni identity sync message');
2022-07-28 16:35:29 +00:00
return;
}
2022-07-28 16:35:29 +00:00
const manager = window.getAccountManager();
await manager.updatePNIIdentity({ privKey: privateKey, pubKey: publicKey });
}
2022-07-28 16:35:29 +00:00
// Runs on TaskType.Encrypted queue
private async handlePNIChangeNumber(
envelope: ProcessedEnvelope,
{
identityKeyPair,
signedPreKey,
registrationId,
}: Proto.SyncMessage.IPniChangeNumber
): Promise<void> {
log.info('MessageReceiver: got pni change number sync message');
logUnexpectedUrgentValue(envelope, 'pniIdentitySync');
const { updatedPni } = envelope;
if (!updatedPni) {
log.warn('MessageReceiver: missing pni in change number sync message');
return;
}
2022-07-28 16:35:29 +00:00
if (
!Bytes.isNotEmpty(identityKeyPair) ||
!Bytes.isNotEmpty(signedPreKey) ||
!isNumber(registrationId)
) {
log.warn('MessageReceiver: empty pni change number sync message');
return;
}
const manager = window.getAccountManager();
await manager.setPni(updatedPni.toString(), {
identityKeyPair,
signedPreKey,
registrationId,
});
}
private async handleStickerPackOperation(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
operations: Array<Proto.SyncMessage.IStickerPackOperation>
): Promise<void> {
2021-07-09 19:36:10 +00:00
const ENUM = Proto.SyncMessage.StickerPackOperation.Type;
log.info('got sticker pack operation sync message');
logUnexpectedUrgentValue(envelope, 'stickerPackSync');
2021-07-09 19:36:10 +00:00
const stickerPacks = operations.map(operation => ({
id: operation.packId ? Bytes.toHex(operation.packId) : undefined,
key: operation.packKey ? Bytes.toBase64(operation.packKey) : undefined,
isInstall: operation.type === ENUM.INSTALL,
isRemove: operation.type === ENUM.REMOVE,
}));
2021-07-09 19:36:10 +00:00
const ev = new StickerPackEvent(
stickerPacks,
this.removeFromCache.bind(this, envelope)
);
return this.dispatchAndWait(ev);
}
private async handleRead(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
read: Array<Proto.SyncMessage.IRead>
): Promise<void> {
log.info('MessageReceiver.handleRead', getEnvelopeId(envelope));
logUnexpectedUrgentValue(envelope, 'readSync');
const results = [];
2021-07-09 19:36:10 +00:00
for (const { timestamp, sender, senderUuid } of read) {
const ev = new ReadSyncEvent(
{
envelopeTimestamp: envelope.timestamp,
2022-03-23 20:49:27 +00:00
timestamp: timestamp?.toNumber(),
2021-07-09 19:36:10 +00:00
sender: dropNull(sender),
senderUuid: senderUuid
? normalizeUuid(senderUuid, 'handleRead.senderUuid')
: undefined,
},
this.removeFromCache.bind(this, envelope)
);
results.push(this.dispatchAndWait(ev));
}
await Promise.all(results);
}
private async handleViewed(
envelope: ProcessedEnvelope,
viewed: ReadonlyArray<Proto.SyncMessage.IViewed>
): Promise<void> {
log.info('MessageReceiver.handleViewed', getEnvelopeId(envelope));
logUnexpectedUrgentValue(envelope, 'viewSync');
await Promise.all(
viewed.map(async ({ timestamp, senderE164, senderUuid }) => {
const ev = new ViewSyncEvent(
{
envelopeTimestamp: envelope.timestamp,
2022-03-23 20:49:27 +00:00
timestamp: timestamp?.toNumber(),
senderE164: dropNull(senderE164),
senderUuid: senderUuid
? normalizeUuid(senderUuid, 'handleViewed.senderUuid')
: undefined,
},
this.removeFromCache.bind(this, envelope)
);
await this.dispatchAndWait(ev);
})
);
}
private async handleContacts(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
contacts: Proto.SyncMessage.IContacts
): Promise<void> {
log.info(`MessageReceiver: handleContacts ${getEnvelopeId(envelope)}`);
const { blob } = contacts;
if (!blob) {
throw new Error('MessageReceiver.handleContacts: blob field was missing');
}
logUnexpectedUrgentValue(envelope, 'contactSync');
this.removeFromCache(envelope);
2021-07-09 19:36:10 +00:00
const attachmentPointer = await this.handleAttachment(blob);
const contactBuffer = new ContactBuffer(attachmentPointer.data);
2022-08-25 05:04:42 +00:00
const contactSync = new ContactSyncEvent(
Array.from(contactBuffer),
Boolean(contacts.complete),
envelope.receivedAtCounter,
envelope.timestamp
2022-08-25 05:04:42 +00:00
);
await this.dispatchAndWait(contactSync);
2022-03-02 22:53:47 +00:00
log.info('handleContacts: finished');
}
private async handleGroups(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
groups: Proto.SyncMessage.IGroups
): Promise<void> {
log.info('group sync');
log.info(`MessageReceiver: handleGroups ${getEnvelopeId(envelope)}`);
const { blob } = groups;
this.removeFromCache(envelope);
logUnexpectedUrgentValue(envelope, 'groupSync');
if (!blob) {
throw new Error('MessageReceiver.handleGroups: blob field was missing');
}
// Note: we do not return here because we don't want to block the next message on
// this attachment download and a lot of processing of that attachment.
2021-07-09 19:36:10 +00:00
const attachmentPointer = await this.handleAttachment(blob);
const groupBuffer = new GroupBuffer(attachmentPointer.data);
let groupDetails = groupBuffer.next();
2021-07-09 19:36:10 +00:00
const promises = [];
while (groupDetails) {
const { id } = groupDetails;
strictAssert(id, 'Group details without id');
if (id.byteLength !== 16) {
log.error(
`onGroupReceived: Id was ${id} bytes, expected 16 bytes. Dropping group.`
);
continue;
}
const ev = new GroupEvent(
{
...groupDetails,
id: Bytes.toBinary(id),
},
envelope.receivedAtCounter
);
2021-07-09 19:36:10 +00:00
const promise = this.dispatchAndWait(ev).catch(e => {
log.error('error processing group', e);
});
2021-07-09 19:36:10 +00:00
groupDetails = groupBuffer.next();
promises.push(promise);
}
await Promise.all(promises);
const ev = new GroupSyncEvent();
return this.dispatchAndWait(ev);
}
private async handleBlocked(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
blocked: Proto.SyncMessage.IBlocked
): Promise<void> {
const allIdentifiers = [];
let changed = false;
logUnexpectedUrgentValue(envelope, 'blockSync');
if (blocked.numbers) {
const previous = this.storage.get('blocked', []);
log.info('handleBlocked: Blocking these numbers:', blocked.numbers);
await this.storage.put('blocked', blocked.numbers);
if (!areArraysMatchingSets(previous, blocked.numbers)) {
changed = true;
allIdentifiers.push(...previous);
allIdentifiers.push(...blocked.numbers);
}
}
if (blocked.uuids) {
const previous = this.storage.get('blocked-uuids', []);
2021-07-09 19:36:10 +00:00
const uuids = blocked.uuids.map((uuid, index) => {
return normalizeUuid(uuid, `handleBlocked.uuids.${index}`);
});
log.info('handleBlocked: Blocking these uuids:', uuids);
await this.storage.put('blocked-uuids', uuids);
if (!areArraysMatchingSets(previous, uuids)) {
changed = true;
allIdentifiers.push(...previous);
allIdentifiers.push(...blocked.uuids);
}
}
if (blocked.groupIds) {
const previous = this.storage.get('blocked-groups', []);
const groupV1Ids: Array<string> = [];
const groupIds: Array<string> = [];
blocked.groupIds.forEach(groupId => {
if (groupId.byteLength === GROUPV1_ID_LENGTH) {
groupV1Ids.push(Bytes.toBinary(groupId));
groupIds.push(this.deriveGroupV2FromV1(groupId));
} else if (groupId.byteLength === GROUPV2_ID_LENGTH) {
groupIds.push(Bytes.toBase64(groupId));
} else {
log.error('handleBlocked: Received invalid groupId value');
}
});
log.info(
'handleBlocked: Blocking these groups - v2:',
groupIds.map(groupId => `groupv2(${groupId})`),
'v1:',
groupV1Ids.map(groupId => `group(${groupId})`)
);
const ids = [...groupIds, ...groupV1Ids];
await this.storage.put('blocked-groups', ids);
if (!areArraysMatchingSets(previous, ids)) {
changed = true;
allIdentifiers.push(...previous);
allIdentifiers.push(...ids);
}
}
this.removeFromCache(envelope);
if (changed) {
log.info('handleBlocked: Block list changed, forcing re-render.');
const uniqueIdentifiers = Array.from(new Set(allIdentifiers));
window.ConversationController.forceRerender(uniqueIdentifiers);
}
}
private isBlocked(number: string): boolean {
return this.storage.blocked.isBlocked(number);
}
private isUuidBlocked(uuid: string): boolean {
return this.storage.blocked.isUuidBlocked(uuid);
}
private isGroupBlocked(groupId: string): boolean {
return this.storage.blocked.isGroupBlocked(groupId);
}
private async handleAttachment(
2021-07-09 19:36:10 +00:00
attachment: Proto.IAttachmentPointer
2021-07-14 23:39:52 +00:00
): Promise<DownloadedAttachmentType> {
2021-07-09 19:36:10 +00:00
const cleaned = processAttachment(attachment);
return downloadAttachment(this.server, cleaned);
}
private async handleEndSession(
envelope: ProcessedEnvelope,
theirUuid: UUID
): Promise<void> {
log.info(`handleEndSession: closing sessions for ${theirUuid.toString()}`);
logUnexpectedUrgentValue(envelope, 'resetSession');
await this.storage.protocol.archiveAllSessions(theirUuid);
}
private async processDecrypted(
2021-07-09 19:36:10 +00:00
envelope: ProcessedEnvelope,
decrypted: Proto.IDataMessage
): Promise<ProcessedDataMessage> {
return processDataMessage(decrypted, envelope.timestamp);
}
}
function envelopeTypeToCiphertextType(type: number | undefined): number {
const { Type } = Proto.Envelope;
if (type === Type.CIPHERTEXT) {
return CiphertextMessageType.Whisper;
}
if (type === Type.KEY_EXCHANGE) {
throw new Error(
'envelopeTypeToCiphertextType: Cannot process KEY_EXCHANGE messages'
);
}
if (type === Type.PLAINTEXT_CONTENT) {
return CiphertextMessageType.Plaintext;
}
if (type === Type.PREKEY_BUNDLE) {
return CiphertextMessageType.PreKey;
}
if (type === Type.RECEIPT) {
return CiphertextMessageType.Plaintext;
}
if (type === Type.UNIDENTIFIED_SENDER) {
throw new Error(
'envelopeTypeToCiphertextType: Cannot process UNIDENTIFIED_SENDER messages'
);
}
if (type === Type.UNKNOWN) {
throw new Error(
'envelopeTypeToCiphertextType: Cannot process UNKNOWN messages'
);
}
throw new Error(`envelopeTypeToCiphertextType: Unknown type ${type}`);
}