Page MenuHomePhabricator
Differential D12513

[lib] Discard keyserver usernames for processServerRequestsActionType
ClosedPublic
Actions

Authored by inka on Jun 20 2024, 6:58 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 27, 3:35 PM
Unknown Object (File)
Mar 12 2025, 12:03 PM
Unknown Object (File)
Feb 21 2025, 3:29 PM
Unknown Object (File)
Jan 23 2025, 3:09 AM
Unknown Object (File)
Jan 23 2025, 3:09 AM
Unknown Object (File)
Jan 23 2025, 3:09 AM
Unknown Object (File)
Jan 23 2025, 3:08 AM
Unknown Object (File)
Jan 17 2025, 2:03 AM
View All 57 Files
Subscribers
ashoat

Details

Reviewers
tomek
kamil
Commits
rCOMMc251b8874c5e: [lib] Discard keyserver usernames for processServerRequestsActionType
Summary

issue: ENG-8365

Test Plan

Tested that if processServerRequestsActionType is dispatched with some userInfos in stateChanges and those users are not in the store, the username is set to null

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

inka created this revision.Jun 20 2024, 6:58 AM
Herald added a subscriber: ashoat. · View Herald TranscriptJun 20 2024, 6:58 AM
inka added a parent revision: D12512: [lib] Discard keyserver usernames for incremental state sync and processUpdatesActionType.Jun 20 2024, 6:58 AM
inka added a child revision: D12514: [lib] Discard keyserver usernames for updateUserAvatarActionTypes.Jun 20 2024, 7:02 AM
Harbormaster completed remote builds in B29835: Diff 41570.Jun 20 2024, 7:15 AM
inka requested review of this revision.Jun 20 2024, 7:15 AM
kamil accepted this revision.Jun 21 2024, 3:28 AM
kamil added inline comments.
lib/reducers/user-reducer.js
545 ↗(On Diff #41570)

is this spread needed?

This revision is now accepted and ready to land.Jun 21 2024, 3:28 AM
inka added inline comments.Jun 21 2024, 5:14 AM
lib/reducers/user-reducer.js
545 ↗(On Diff #41570)

Yes, because convertUserInfosToReplaceUserOps returns a read only array and we want to push to this array in the next lines

Closed by commit rCOMMc251b8874c5e: [lib] Discard keyserver usernames for processServerRequestsActionType (authored by inka). · Explain WhyJun 25 2024, 1:22 AM
This revision was automatically updated to reflect the committed changes.
inka added a commit: rCOMMc251b8874c5e: [lib] Discard keyserver usernames for processServerRequestsActionType.

Revision Contents
Changeset List

PathSize
lib/
reducers/
16 lines

Diff 41690

View Options

lib/reducers/user-reducer.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};