Differential D7539 Diff 25464 services/identity/src/client_service.rs

Changeset View

Standalone View

services/identity/src/client_service.rs

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#[derive(Clone)]		#[derive(Clone)]
pub struct RegistrationState {		pub struct RegistrationState {
pub username: String,		pub username: String,
pub flattened_device_key_upload: FlattenedDeviceKeyUpload,		pub flattened_device_key_upload: FlattenedDeviceKeyUpload,
}		}

#[derive(Clone)]		#[derive(Clone)]
pub struct LoginState {		pub struct LoginState {
		pub user_id: String,
pub flattened_device_key_upload: FlattenedDeviceKeyUpload,		pub flattened_device_key_upload: FlattenedDeviceKeyUpload,
pub opaque_server_login: comm_opaque2::server::Login,		pub opaque_server_login: comm_opaque2::server::Login,
}		}

#[derive(Clone)]		#[derive(Clone)]
pub struct FlattenedDeviceKeyUpload {		pub struct FlattenedDeviceKeyUpload {
pub device_id_key: String,		pub device_id_key: String,
pub key_payload: String,		pub key_payload: String,
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines	impl IdentityClientService for ClientService {
}		}

async fn login_password_user_start(		async fn login_password_user_start(
&self,		&self,
request: tonic::Request<OpaqueLoginStartRequest>,		request: tonic::Request<OpaqueLoginStartRequest>,
) -> Result<tonic::Response<OpaqueLoginStartResponse>, tonic::Status> {		) -> Result<tonic::Response<OpaqueLoginStartResponse>, tonic::Status> {
let message = request.into_inner();		let message = request.into_inner();

let password_file_bytes = if let Some(bytes) = self		let (user_id, password_file_bytes) = if let Some((id, bytes)) = self
.client		.client
.get_password_file_from_username(&message.username)		.get_user_id_and_password_file_from_username(&message.username)
.await		.await
.map_err(handle_db_error)?		.map_err(handle_db_error)?
{		{
bytes		(id, bytes)
} else {		} else {
return Err(tonic::Status::not_found("user not found"));		return Err(tonic::Status::not_found("user not found"));
};		};

if let client_proto::OpaqueLoginStartRequest {		if let client_proto::OpaqueLoginStartRequest {
opaque_login_request: login_message,		opaque_login_request: login_message,
username,		username,
device_key_upload:		device_key_upload:
Show All 27 Lines	if let client_proto::OpaqueLoginStartRequest {
&login_message,		&login_message,
username.as_bytes(),		username.as_bytes(),
)		)
.map_err(protocol_error_to_grpc_status)?;		.map_err(protocol_error_to_grpc_status)?;

let key_info = KeyPayload::from_str(&payload)		let key_info = KeyPayload::from_str(&payload)
.map_err(\|_\| tonic::Status::invalid_argument("malformed payload"))?;		.map_err(\|_\| tonic::Status::invalid_argument("malformed payload"))?;
let login_state = LoginState {		let login_state = LoginState {
		user_id,
opaque_server_login: server_login,		opaque_server_login: server_login,
flattened_device_key_upload: FlattenedDeviceKeyUpload {		flattened_device_key_upload: FlattenedDeviceKeyUpload {
device_id_key: key_info.primary_identity_public_keys.curve25519,		device_id_key: key_info.primary_identity_public_keys.curve25519,
key_payload: payload,		key_payload: payload,
key_payload_signature: payload_signature,		key_payload_signature: payload_signature,
identity_prekey,		identity_prekey,
identity_prekey_signature,		identity_prekey_signature,
identity_onetime_keys: onetime_identity_prekeys,		identity_onetime_keys: onetime_identity_prekeys,
Show All 15 Lines	if let client_proto::OpaqueLoginStartRequest {
Ok(response)		Ok(response)
} else {		} else {
Err(tonic::Status::invalid_argument("unexpected message data"))		Err(tonic::Status::invalid_argument("unexpected message data"))
}		}
}		}

async fn login_password_user_finish(		async fn login_password_user_finish(
&self,		&self,
_request: tonic::Request<OpaqueLoginFinishRequest>,		request: tonic::Request<OpaqueLoginFinishRequest>,
) -> Result<tonic::Response<OpaqueLoginFinishResponse>, tonic::Status> {		) -> Result<tonic::Response<OpaqueLoginFinishResponse>, tonic::Status> {
unimplemented!();		let message = request.into_inner();

		if let Some(WorkflowInProgress::Login(state)) =
		self.cache.get(&message.session_id)
		{
		self.cache.invalidate(&message.session_id).await;

		let mut server_login = state.opaque_server_login.clone();
		server_login
		.finish(&message.opaque_login_upload)
		.map_err(protocol_error_to_grpc_status)?;

		self
		.client
		.add_device_to_users_table(state.clone())
		.await
		.map_err(handle_db_error)?;

		// Create access token
		let token = AccessTokenData::new(
		message.session_id,
		state.flattened_device_key_upload.device_id_key,
		crate::token::AuthType::Password,
		&mut OsRng,
		);

		let access_token = token.access_token.clone();

		self
		.client
		.put_access_token_data(token)
		.await
		.map_err(handle_db_error)?;

		let response = OpaqueLoginFinishResponse {
		user_id: state.user_id,
		access_token,
		};
		Ok(Response::new(response))
		} else {
		Err(tonic::Status::not_found("session not found"))
		}
}		}

async fn login_wallet_user(		async fn login_wallet_user(
&self,		&self,
_request: tonic::Request<WalletLoginRequest>,		_request: tonic::Request<WalletLoginRequest>,
) -> Result<tonic::Response<WalletLoginResponse>, tonic::Status> {		) -> Result<tonic::Response<WalletLoginResponse>, tonic::Status> {
unimplemented!();		unimplemented!();
}		}
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines