Page MenuHomePhabricator
Differential D14205

rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos
ClosedPublic
Actions

Authored by varun on Jan 14 2025, 2:57 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 22, 8:50 AM
Unknown Object (File)
Sun, Mar 16, 6:20 AM
Unknown Object (File)
Sun, Mar 16, 6:20 AM
Unknown Object (File)
Sun, Mar 16, 6:20 AM
Unknown Object (File)
Fri, Mar 14, 11:47 PM
Unknown Object (File)
Fri, Mar 14, 11:47 PM
Unknown Object (File)
Fri, Mar 14, 6:20 AM
Unknown Object (File)
Fri, Mar 14, 4:08 AM
View All 42 Files
Subscribers
tomek

Details

Reviewers
ashoat
Commits
rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos
Summary

Depends on D14204

Test Plan

was still able to call endpoint from community drawer

this API isn't being used anywhere yet so no need to worry about older clients

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

varun created this revision.Jan 14 2025, 2:57 PM
varun held this revision as a draft.
Herald added a subscriber: tomek. · View Herald TranscriptJan 14 2025, 2:57 PM
Harbormaster failed remote builds in B33243: Diff 46685!Jan 14 2025, 3:11 PM
varun updated this revision to Diff 46847.Jan 29 2025, 5:36 PM

CI

varun edited the test plan for this revision. (Show Details)Jan 29 2025, 5:36 PM
varun edited the test plan for this revision. (Show Details)
Harbormaster completed remote builds in B33350: Diff 46847.Jan 29 2025, 5:56 PM
varun published this revision for review.Jan 29 2025, 5:57 PM
ashoat accepted this revision.Jan 30 2025, 10:55 AM
ashoat added inline comments.
keyserver/src/endpoints.js
509 ↗(On Diff #46847)

Is it definitely safe to rename this? No calls from production?

This revision is now accepted and ready to land.Jan 30 2025, 10:55 AM
varun added inline comments.Feb 3 2025, 4:32 PM
keyserver/src/endpoints.js
509 ↗(On Diff #46847)

yeah

varun added a child revision: D14378: [keyserver] boost certain community IDs.Feb 17 2025, 3:46 PM
Closed by commit rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos (authored by varun). · Explain WhyMar 1 2025, 2:25 PM
This revision was automatically updated to reflect the committed changes.
varun added a commit: rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos.

Revision Contents
Changeset List

PathSize
keyserver/
src/
6 lines
fetchers/
4 lines
responders/
12 lines
scripts/
4 lines
lib/
actions/
20 lines
reducers/
4 lines
types/
4 lines
3 lines
10 lines
validators/
6 lines
6 lines
native/
components/
8 lines
navigation/
14 lines

Diff 47322

View Options

keyserver/src/endpoints.js

// @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

keyserver/src/fetchers/community-fetchers.js

// @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

keyserver/src/responders/community-responders.js

// @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

keyserver/src/scripts/delete-all-fc-channel-tags.js

// @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

lib/actions/community-actions.js

// @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

lib/reducers/community-reducer.js

// @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

lib/types/community-types.js

// @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

lib/types/endpoints.js

Loading...
View Options

lib/types/redux-types.js

Loading...
View Options

lib/types/validators/community-validators.js

Loading...
View Options

lib/types/validators/endpoint-validators.js

Loading...
View Options

native/components/display-community-directory-prompt.react.js

Loading...
View Options

native/navigation/community-drawer-content.react.js

Loading...