Page MenuHomePhabricator
Differential D14198

[protos] Add skipPasswordReset field to PrivilegedResetUserPassword
ClosedPublic
Actions

Authored by bartek on Jan 13 2025, 6:44 AM.
Tags
None
Referenced Files
F5287304: D14198.diff
Mon, Apr 7, 12:57 PM
Unknown Object (File)
Sat, Mar 15, 12:21 AM
Unknown Object (File)
Sat, Mar 15, 12:21 AM
Unknown Object (File)
Sat, Mar 15, 12:20 AM
Unknown Object (File)
Sat, Mar 15, 12:19 AM
Unknown Object (File)
Feb 12 2025, 6:25 PM
Unknown Object (File)
Feb 12 2025, 6:24 PM
Unknown Object (File)
Feb 12 2025, 6:22 PM
View All 35 Files
Subscribers
None

Details

Reviewers
ashoat
kamil
tomek
Commits
rCOMMbfa565f46076: [protos] Add skipPasswordReset field to PrivilegedResetUserPassword
Summary

Part of ENG-9628

As mentioned in this discussion, we want a flag to skip password reset while reverting users to V1 flows.

Test Plan

CI, flow

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
addons/
rust-node-addon/
src/
identity_client/
1 line
shared/
protos/
2 lines
web/
protobufs/
4 lines

Diff 46671

View Options

keyserver/addons/rust-node-addon/src/identity_client/privileged_reset_user_password.rs

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines connectionChangePromise.current = (async () => {
} }
} else if ( } else if (
message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE
) { ) {
const confirmation: MessageReceiveConfirmation = { const confirmation: MessageReceiveConfirmation = {
type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION, type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION,
messageIDs: [message.messageID], messageIDs: [message.messageID],
}; };
socket.current?.send(JSON.stringify(confirmation));
let rawPeerToPeerMessage; let rawPeerToPeerMessage;
try { try {
rawPeerToPeerMessage = JSON.parse(message.payload); rawPeerToPeerMessage = JSON.parse(message.payload);
} catch (e) { } catch (e) {
console.log( console.log(
'error while parsing Tunnelbroker peer-to-peer message:', 'error while parsing Tunnelbroker peer-to-peer message:',
e.message, e.message,
); );
// Client received incorrect message, confirm to remove from
// Tunnelbroker queue.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) { if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) {
console.log('invalid Tunnelbroker PeerToPeerMessage'); console.log('invalid Tunnelbroker PeerToPeerMessage');
// The client received an invalid Tunnelbroker message,
// and cannot process this type of request.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage; const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage;
currentlyProcessedMessage.current = (async () => { currentlyProcessedMessage.current = (async () => {
const localSocketSessionCounter = socketSessionCounter.current; const localSocketSessionCounter = socketSessionCounter.current;
await currentlyProcessedMessage.current; await currentlyProcessedMessage.current;
// Since scheduling processing this message socket is closed // Since scheduling processing this message socket is closed
// or was closed and reopened, we have to stop processing // or was closed and reopened, we have to stop processing
Show All 9 Lines connectionChangePromise.current = (async () => {
try { try {
await peerToPeerMessageHandler( await peerToPeerMessageHandler(
peerToPeerMessage, peerToPeerMessage,
identityClient, identityClient,
message.messageID, message.messageID,
); );
} catch (e) { } catch (e) {
console.log(e.message); console.log(e.message);
} finally {
if (
localSocketSessionCounter === socketSessionCounter.current &&
socket.current
) {
// We confirm regardless of success or error while processing.
socket.current.send(JSON.stringify(confirmation));
}
} }
})(); })();
} else if ( } else if (
message.type === message.type ===
tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS
) { ) {
for (const status: MessageSentStatus of message.clientMessageIDs) { for (const status: MessageSentStatus of message.clientMessageIDs) {
if (status.type === 'Success') { if (status.type === 'Success') {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines
View Options

shared/protos/identity_auth.proto

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines connectionChangePromise.current = (async () => {
} }
} else if ( } else if (
message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE
) { ) {
const confirmation: MessageReceiveConfirmation = { const confirmation: MessageReceiveConfirmation = {
type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION, type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION,
messageIDs: [message.messageID], messageIDs: [message.messageID],
}; };
socket.current?.send(JSON.stringify(confirmation));
let rawPeerToPeerMessage; let rawPeerToPeerMessage;
try { try {
rawPeerToPeerMessage = JSON.parse(message.payload); rawPeerToPeerMessage = JSON.parse(message.payload);
} catch (e) { } catch (e) {
console.log( console.log(
'error while parsing Tunnelbroker peer-to-peer message:', 'error while parsing Tunnelbroker peer-to-peer message:',
e.message, e.message,
); );
// Client received incorrect message, confirm to remove from
// Tunnelbroker queue.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) { if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) {
console.log('invalid Tunnelbroker PeerToPeerMessage'); console.log('invalid Tunnelbroker PeerToPeerMessage');
// The client received an invalid Tunnelbroker message,
// and cannot process this type of request.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage; const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage;
currentlyProcessedMessage.current = (async () => { currentlyProcessedMessage.current = (async () => {
const localSocketSessionCounter = socketSessionCounter.current; const localSocketSessionCounter = socketSessionCounter.current;
await currentlyProcessedMessage.current; await currentlyProcessedMessage.current;
// Since scheduling processing this message socket is closed // Since scheduling processing this message socket is closed
// or was closed and reopened, we have to stop processing // or was closed and reopened, we have to stop processing
Show All 9 Lines connectionChangePromise.current = (async () => {
try { try {
await peerToPeerMessageHandler( await peerToPeerMessageHandler(
peerToPeerMessage, peerToPeerMessage,
identityClient, identityClient,
message.messageID, message.messageID,
); );
} catch (e) { } catch (e) {
console.log(e.message); console.log(e.message);
} finally {
if (
localSocketSessionCounter === socketSessionCounter.current &&
socket.current
) {
// We confirm regardless of success or error while processing.
socket.current.send(JSON.stringify(confirmation));
}
} }
})(); })();
} else if ( } else if (
message.type === message.type ===
tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS
) { ) {
for (const status: MessageSentStatus of message.clientMessageIDs) { for (const status: MessageSentStatus of message.clientMessageIDs) {
if (status.type === 'Success') { if (status.type === 'Success') {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines
View Options

web/protobufs/identity-auth-structs.cjs

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines connectionChangePromise.current = (async () => {
} }
} else if ( } else if (
message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE
) { ) {
const confirmation: MessageReceiveConfirmation = { const confirmation: MessageReceiveConfirmation = {
type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION, type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION,
messageIDs: [message.messageID], messageIDs: [message.messageID],
}; };
socket.current?.send(JSON.stringify(confirmation));
let rawPeerToPeerMessage; let rawPeerToPeerMessage;
try { try {
rawPeerToPeerMessage = JSON.parse(message.payload); rawPeerToPeerMessage = JSON.parse(message.payload);
} catch (e) { } catch (e) {
console.log( console.log(
'error while parsing Tunnelbroker peer-to-peer message:', 'error while parsing Tunnelbroker peer-to-peer message:',
e.message, e.message,
); );
// Client received incorrect message, confirm to remove from
// Tunnelbroker queue.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) { if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) {
console.log('invalid Tunnelbroker PeerToPeerMessage'); console.log('invalid Tunnelbroker PeerToPeerMessage');
// The client received an invalid Tunnelbroker message,
// and cannot process this type of request.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage; const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage;
currentlyProcessedMessage.current = (async () => { currentlyProcessedMessage.current = (async () => {
const localSocketSessionCounter = socketSessionCounter.current; const localSocketSessionCounter = socketSessionCounter.current;
await currentlyProcessedMessage.current; await currentlyProcessedMessage.current;
// Since scheduling processing this message socket is closed // Since scheduling processing this message socket is closed
// or was closed and reopened, we have to stop processing // or was closed and reopened, we have to stop processing
Show All 9 Lines connectionChangePromise.current = (async () => {
try { try {
await peerToPeerMessageHandler( await peerToPeerMessageHandler(
peerToPeerMessage, peerToPeerMessage,
identityClient, identityClient,
message.messageID, message.messageID,
); );
} catch (e) { } catch (e) {
console.log(e.message); console.log(e.message);
} finally {
if (
localSocketSessionCounter === socketSessionCounter.current &&
socket.current
) {
// We confirm regardless of success or error while processing.
socket.current.send(JSON.stringify(confirmation));
}
} }
})(); })();
} else if ( } else if (
message.type === message.type ===
tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS
) { ) {
for (const status: MessageSentStatus of message.clientMessageIDs) { for (const status: MessageSentStatus of message.clientMessageIDs) {
if (status.type === 'Success') { if (status.type === 'Success') {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines
View Options

web/protobufs/identity-auth-structs.cjs.flow

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines connectionChangePromise.current = (async () => {
} }
} else if ( } else if (
message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE message.type === tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE
) { ) {
const confirmation: MessageReceiveConfirmation = { const confirmation: MessageReceiveConfirmation = {
type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION, type: tunnelbrokerMessageTypes.MESSAGE_RECEIVE_CONFIRMATION,
messageIDs: [message.messageID], messageIDs: [message.messageID],
}; };
socket.current?.send(JSON.stringify(confirmation));
let rawPeerToPeerMessage; let rawPeerToPeerMessage;
try { try {
rawPeerToPeerMessage = JSON.parse(message.payload); rawPeerToPeerMessage = JSON.parse(message.payload);
} catch (e) { } catch (e) {
console.log( console.log(
'error while parsing Tunnelbroker peer-to-peer message:', 'error while parsing Tunnelbroker peer-to-peer message:',
e.message, e.message,
); );
// Client received incorrect message, confirm to remove from
// Tunnelbroker queue.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) { if (!peerToPeerMessageValidator.is(rawPeerToPeerMessage)) {
console.log('invalid Tunnelbroker PeerToPeerMessage'); console.log('invalid Tunnelbroker PeerToPeerMessage');
// The client received an invalid Tunnelbroker message,
// and cannot process this type of request.
socket.current?.send(JSON.stringify(confirmation));
return; return;
} }
const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage; const peerToPeerMessage: PeerToPeerMessage = rawPeerToPeerMessage;
currentlyProcessedMessage.current = (async () => { currentlyProcessedMessage.current = (async () => {
const localSocketSessionCounter = socketSessionCounter.current; const localSocketSessionCounter = socketSessionCounter.current;
await currentlyProcessedMessage.current; await currentlyProcessedMessage.current;
// Since scheduling processing this message socket is closed // Since scheduling processing this message socket is closed
// or was closed and reopened, we have to stop processing // or was closed and reopened, we have to stop processing
Show All 9 Lines connectionChangePromise.current = (async () => {
try { try {
await peerToPeerMessageHandler( await peerToPeerMessageHandler(
peerToPeerMessage, peerToPeerMessage,
identityClient, identityClient,
message.messageID, message.messageID,
); );
} catch (e) { } catch (e) {
console.log(e.message); console.log(e.message);
} finally {
if (
localSocketSessionCounter === socketSessionCounter.current &&
socket.current
) {
// We confirm regardless of success or error while processing.
socket.current.send(JSON.stringify(confirmation));
}
} }
})(); })();
} else if ( } else if (
message.type === message.type ===
tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST_STATUS
) { ) {
for (const status: MessageSentStatus of message.clientMessageIDs) { for (const status: MessageSentStatus of message.clientMessageIDs) {
if (status.type === 'Success') { if (status.type === 'Success') {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines