Page MenuHomePhabricator
Differential D14172

[identity] Allow v1 login for authoritative keyserver
ClosedPublic
Actions

Authored by bartek on Dec 19 2024, 1:49 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 31, 11:44 AM
Unknown Object (File)
Thu, Mar 27, 6:02 PM
Unknown Object (File)
Wed, Mar 26, 4:48 PM
Unknown Object (File)
Wed, Mar 26, 2:28 AM
Unknown Object (File)
Tue, Mar 25, 12:34 PM
Unknown Object (File)
Sat, Mar 15, 4:25 PM
Unknown Object (File)
Sat, Mar 15, 4:25 PM
Unknown Object (File)
Sat, Mar 15, 4:25 PM
View All 52 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
Commits
rCOMM58bf345631bc: [identity] Allow v1 login for authoritative keyserver
Summary

Address ENG-10012.

Test Plan

Mocked AUTHORITATIVE_KEYSERVER_OWNER_USER_ID with my user ID and verified that v1 login works for my keyserver despite having signed device list

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
services/
identity/
src/
17 lines
1 line

Diff 46588

View Options

services/identity/src/client_service.rs

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines
View Options

services/identity/src/constants.rs

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines