Page MenuHomePhabricator
Differential D14486

[native] Script to bump native version
ClosedPublic
Actions

Authored by ashoat on Thu, Mar 20, 7:24 PM.
Tags
None
Referenced Files
F5100062: D14486.diff
Mon, Mar 31, 10:25 AM
F5093876: D14486.id47511.diff
Sun, Mar 30, 1:51 PM
Unknown Object (File)
Sun, Mar 30, 11:02 AM
Unknown Object (File)
Sun, Mar 30, 9:32 AM
Unknown Object (File)
Sun, Mar 30, 3:28 AM
Unknown Object (File)
Sat, Mar 29, 7:06 PM
Unknown Object (File)
Sat, Mar 29, 9:01 AM
Unknown Object (File)
Sat, Mar 29, 7:25 AM
View All 55 Files
Subscribers
None

Details

Reviewers
tomek
angelika
Commits
rCOMM06bd90759920: [native] Script to bump native version
Summary

Claude helped generate this. Will save me some time during release processes.

Test Plan

Ran the script and it worked!

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

ashoat created this revision.Thu, Mar 20, 7:24 PM
ashoat updated this revision to Diff 47512.Thu, Mar 20, 7:28 PM

Fix Flow

ashoat updated this revision to Diff 47513.Thu, Mar 20, 7:30 PM

Accidentally had bumped version in version.js

ashoat updated this revision to Diff 47514.Thu, Mar 20, 7:32 PM

Minor: update comment

Harbormaster failed remote builds in B33801: Diff 47511!Thu, Mar 20, 7:33 PM
Harbormaster failed remote builds in B33802: Diff 47512!Thu, Mar 20, 7:42 PM
Harbormaster failed remote builds in B33803: Diff 47513!
Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 7:45 PM
Harbormaster failed remote builds in B33804: Diff 47514!
ashoat updated this revision to Diff 47515.Thu, Mar 20, 8:21 PM

Avoid setting type: "module" in native/package.json as it breaks some scripts

Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 8:30 PM
Harbormaster failed remote builds in B33805: Diff 47515!
ashoat updated this revision to Diff 47516.Thu, Mar 20, 8:48 PM

Add .mjs files to .flowconfig

Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 8:56 PM
Harbormaster failed remote builds in B33806: Diff 47516!
ashoat added inline comments.Thu, Mar 20, 9:03 PM
native/scripts/update-mobile-version.mjs
5 ↗(On Diff #47516)
Harbormaster completed remote builds in B33806: Diff 47516.Thu, Mar 20, 9:08 PM
ashoat requested review of this revision.Thu, Mar 20, 9:08 PM
angelika accepted this revision.Fri, Mar 21, 12:32 AM

LGTM, but:

  • don't we need to document it somewhere in some README?
  • as far as I understand to update the version you bump the version in version.mjs first, then run the script, can't we automate the first step too?
  • you can also automate making commits too later?
This revision is now accepted and ready to land.Fri, Mar 21, 12:32 AM
tomek accepted this revision.Fri, Mar 21, 4:20 AM
ashoat added a comment.Fri, Mar 21, 3:59 PM
  • don't we need to document it somewhere in some README?

No, I don't think so. We don't really document the release process in the README.

  • as far as I understand to update the version you bump the version in version.mjs first, then run the script, can't we automate the first step too?

Yeah, and I think this could be done for keyserver and web too. But I'm starting with this script because it's currently the most annoying / rote part of the process for me. Hope to make further improvements at a later point.

  • you can also automate making commits too later?

Yeah agree we could improve the process further.

ashoat updated this revision to Diff 47518.Fri, Mar 21, 3:59 PM

Update comment

ashoat updated this revision to Diff 47519.Fri, Mar 21, 4:01 PM

One more comment update

Harbormaster completed remote builds in B33808: Diff 47518.Fri, Mar 21, 4:18 PM
Harbormaster completed remote builds in B33809: Diff 47519.
Closed by commit rCOMM06bd90759920: [native] Script to bump native version (authored by ashoat). · Explain WhyFri, Mar 21, 4:20 PM
This revision was automatically updated to reflect the committed changes.
ashoat added a commit: rCOMM06bd90759920: [native] Script to bump native version.

Revision Contents
Changeset List

PathSize
native/
1 line
cpp/
CommonCpp/
NativeModules/
1 line
3 lines
redux/
3 lines
scripts/
147 lines
4 lines

Diff 47520

View Options

native/.flowconfig

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

native/package.json

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

native/redux/persist.js

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

native/scripts/update-mobile-version.mjs

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

native/version.mjs

Loading...