Paths

Table of Contentst

-
services/identity/src/
-
identity/
-
src/
-
device_list.rs
-
grpc_services/
2/2
authenticated.rs

[identity] Implement LogOutPrimaryDevice RPC
ClosedPublic
Actions

Authored by bartek on Jun 27 2024, 7:38 AM.

Details

Reviewers

kamil
varun
will

Commits

rCOMM33f97a51114a: [identity] Implement LogOutPrimaryDevice RPC

Summary

Implemented the RPC for primary device logout. It:

Verifies if the RPC is called by a primary device
Validates received device list: if it is a singleton of the primary device
Applies the updated device list
Revokes user device's CSATs
Removes devices' data and OTKs

Depends on D12571, D12589

Test Plan

Created a user with a few devices. Used function from D12586 to call this RPC:

It failed when called from secondary device
It failed when deliberately malformed the device list payload or used a different device ID
It succeeded when called from primary device. Verified DDB:
- Users table item was still there
- Devices table contained the singleton device list. No device data was present
- OTKs and tokens were gone

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

bartek created this revision.Jun 27 2024, 7:38 AM

bartek held this revision as a draft.

Herald added subscribers: tomek, ashoat. · View Herald TranscriptJun 27 2024, 7:38 AM

Rebase

Harbormaster failed remote builds in B29955: Diff 41752!Jun 27 2024, 8:21 AM

Harbormaster completed remote builds in B29961: Diff 41758.Jun 27 2024, 8:47 AM

bartek published this revision for review.Jun 28 2024, 1:08 AM

bartek added inline comments.

services/identity/src/grpc_services/authenticated.rs
493 ↗	(On Diff #41758)	This will be done when D12526 is landed

kamil accepted this revision.Jul 1 2024, 3:12 AM

This revision is now accepted and ready to land.Jul 1 2024, 3:12 AM

bartek added a child revision: D12649: [identity] Delete Tunnelbroker data on primary device logout.Jul 3 2024, 2:45 AM

bartek added inline comments.Jul 3 2024, 2:46 AM

services/identity/src/grpc_services/authenticated.rs
493 ↗	(On Diff #41758)	Addressed in D12649

Closed by commit rCOMM33f97a51114a: [identity] Implement LogOutPrimaryDevice RPC (authored by bartek). · Explain WhyJul 3 2024, 3:08 AM

This revision was automatically updated to reflect the committed changes.

bartek added a commit: rCOMM33f97a51114a: [identity] Implement LogOutPrimaryDevice RPC.

Revision Contents
Changeset List

Path

Size

services/

identity/

src/

device_list.rs

3 lines

grpc_services/

authenticated.rs

71 lines

Diff 41752

View Options

services/identity/src/device_list.rs

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };