Differential D7706 Diff 26048 native/native_rust_library/src/lib.rs

Changeset View

Standalone View

native/native_rust_library/src/lib.rs

use crate::ffi::string_callback;		use crate::ffi::string_callback;
use crate::identity::Empty;		use crate::identity::Empty;
use comm_opaque2::client::Registration;		use comm_opaque2::client::{Login, Registration};
use comm_opaque2::grpc::opaque_error_to_grpc_status as handle_error;		use comm_opaque2::grpc::opaque_error_to_grpc_status as handle_error;
use lazy_static::lazy_static;		use lazy_static::lazy_static;
use serde::Serialize;		use serde::Serialize;
use std::sync::Arc;		use std::sync::Arc;
use tokio::runtime::{Builder, Runtime};		use tokio::runtime::{Builder, Runtime};
use tonic::{transport::Channel, Status};		use tonic::{transport::Channel, Status};
use tracing::instrument;		use tracing::instrument;

mod crypto_tools;		mod crypto_tools;
mod identity_client;		mod identity_client;
mod identity {		mod identity {
tonic::include_proto!("identity.client");		tonic::include_proto!("identity.client");
}		}

use crypto_tools::generate_device_id;		use crypto_tools::generate_device_id;
use identity::identity_client_service_client::IdentityClientServiceClient;		use identity::identity_client_service_client::IdentityClientServiceClient;
use identity::{		use identity::{
DeviceKeyUpload, IdentityKeyInfo, PreKey, RegistrationFinishRequest,		DeviceKeyUpload, IdentityKeyInfo, OpaqueLoginFinishRequest,
		OpaqueLoginStartRequest, PreKey, RegistrationFinishRequest,
RegistrationStartRequest,		RegistrationStartRequest,
};		};

lazy_static! {		lazy_static! {
pub static ref RUNTIME: Arc<Runtime> = Arc::new(		pub static ref RUNTIME: Arc<Runtime> = Arc::new(
Builder::new_multi_thread()		Builder::new_multi_thread()
.worker_threads(1)		.worker_threads(1)
.max_blocking_threads(1)		.max_blocking_threads(1)
Show All 29 Lines	fn register_user(
content_prekey_signature: String,		content_prekey_signature: String,
notif_prekey: String,		notif_prekey: String,
notif_prekey_signature: String,		notif_prekey_signature: String,
content_onetime_keys: Vec<String>,		content_onetime_keys: Vec<String>,
notif_onetime_keys: Vec<String>,		notif_onetime_keys: Vec<String>,
promise_id: u32,		promise_id: u32,
);		);

#[cxx_name = "identityLoginUserPakeBlocking"]		#[cxx_name = "identityLoginPasswordUser"]
fn identity_login_user_pake_blocking(		fn login_password_user(
client: Box<IdentityClient>,
username: String,		username: String,
password: String,		password: String,
key_payload: String,		key_payload: String,
key_payload_signature: String,		key_payload_signature: String,
identity_prekey: String,		content_prekey: String,
identity_prekey_signature: String,		content_prekey_signature: String,
notif_prekey: String,		notif_prekey: String,
notif_prekey_signature: String,		notif_prekey_signature: String,
identity_onetime_keys: Vec<String>,		content_onetime_keys: Vec<String>,
notif_onetime_keys: Vec<String>,		notif_onetime_keys: Vec<String>,
) -> Result<String>;		promise_id: u32,
		);

#[cxx_name = "identityLoginUserWalletBlocking"]		#[cxx_name = "identityLoginUserWalletBlocking"]
fn identity_login_user_wallet_blocking(		fn identity_login_user_wallet_blocking(
client: Box<IdentityClient>,		client: Box<IdentityClient>,
siwe_message: String,		siwe_message: String,
siwe_signature: String,		siwe_signature: String,
key_payload: String,		key_payload: String,
key_payload_signature: String,		key_payload_signature: String,
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines	fn register_user(
content_prekey_signature: String,		content_prekey_signature: String,
notif_prekey: String,		notif_prekey: String,
notif_prekey_signature: String,		notif_prekey_signature: String,
content_onetime_keys: Vec<String>,		content_onetime_keys: Vec<String>,
notif_onetime_keys: Vec<String>,		notif_onetime_keys: Vec<String>,
promise_id: u32,		promise_id: u32,
) {		) {
RUNTIME.spawn(async move {		RUNTIME.spawn(async move {
let register_user_info = RegisterUserInfo {		let password_user_info = PasswordUserInfo {
username,		username,
password,		password,
key_payload,		key_payload,
key_payload_signature,		key_payload_signature,
content_prekey,		content_prekey,
content_prekey_signature,		content_prekey_signature,
notif_prekey,		notif_prekey,
notif_prekey_signature,		notif_prekey_signature,
content_onetime_keys,		content_onetime_keys,
notif_onetime_keys,		notif_onetime_keys,
};		};
let result = register_user_helper(register_user_info).await;		let result = register_user_helper(password_user_info).await;
handle_string_result_as_callback(result, promise_id);		handle_string_result_as_callback(result, promise_id);
});		});
}		}

struct RegisterUserInfo {		struct PasswordUserInfo {
username: String,		username: String,
password: String,		password: String,
key_payload: String,		key_payload: String,
key_payload_signature: String,		key_payload_signature: String,
content_prekey: String,		content_prekey: String,
content_prekey_signature: String,		content_prekey_signature: String,
notif_prekey: String,		notif_prekey: String,
notif_prekey_signature: String,		notif_prekey_signature: String,
content_onetime_keys: Vec<String>,		content_onetime_keys: Vec<String>,
notif_onetime_keys: Vec<String>,		notif_onetime_keys: Vec<String>,
}		}

#[derive(Serialize)]		#[derive(Serialize)]
struct UserIDAndDeviceAccessToken {		struct UserIDAndDeviceAccessToken {
user_id: String,		user_id: String,
access_token: String,		access_token: String,
}		}

async fn register_user_helper(		async fn register_user_helper(
register_user_info: RegisterUserInfo,		password_user_info: PasswordUserInfo,
) -> Result<String, Error> {		) -> Result<String, Error> {
let mut client_registration = Registration::new();		let mut client_registration = Registration::new();
let opaque_registration_request = client_registration		let opaque_registration_request = client_registration
.start(&register_user_info.password)		.start(&password_user_info.password)
.map_err(handle_error)?;		.map_err(handle_error)?;
let registration_start_request = RegistrationStartRequest {		let registration_start_request = RegistrationStartRequest {
opaque_registration_request,		opaque_registration_request,
username: register_user_info.username,		username: password_user_info.username,
device_key_upload: Some(DeviceKeyUpload {		device_key_upload: Some(DeviceKeyUpload {
device_key_info: Some(IdentityKeyInfo {		device_key_info: Some(IdentityKeyInfo {
payload: register_user_info.key_payload,		payload: password_user_info.key_payload,
payload_signature: register_user_info.key_payload_signature,		payload_signature: password_user_info.key_payload_signature,
social_proof: None,		social_proof: None,
}),		}),
content_upload: Some(PreKey {		content_upload: Some(PreKey {
pre_key: register_user_info.content_prekey,		pre_key: password_user_info.content_prekey,
pre_key_signature: register_user_info.content_prekey_signature,		pre_key_signature: password_user_info.content_prekey_signature,
}),		}),
notif_upload: Some(PreKey {		notif_upload: Some(PreKey {
pre_key: register_user_info.notif_prekey,		pre_key: password_user_info.notif_prekey,
pre_key_signature: register_user_info.notif_prekey_signature,		pre_key_signature: password_user_info.notif_prekey_signature,
}),		}),
onetime_content_prekeys: register_user_info.content_onetime_keys,		onetime_content_prekeys: password_user_info.content_onetime_keys,
onetime_notif_prekeys: register_user_info.notif_onetime_keys,		onetime_notif_prekeys: password_user_info.notif_onetime_keys,
}),		}),
};		};

let mut identity_client =		let mut identity_client =
IdentityClientServiceClient::connect("http://127.0.0.1:50054").await?;		IdentityClientServiceClient::connect("http://127.0.0.1:50054").await?;
let registration_start_response = identity_client		let registration_start_response = identity_client
.register_password_user_start(registration_start_request)		.register_password_user_start(registration_start_request)
.await?		.await?
.into_inner();		.into_inner();

let opaque_registration_upload = client_registration		let opaque_registration_upload = client_registration
.finish(		.finish(
&register_user_info.password,		&password_user_info.password,
&registration_start_response.opaque_registration_response,		&registration_start_response.opaque_registration_response,
)		)
.map_err(handle_error)?;		.map_err(handle_error)?;
let registration_finish_request = RegistrationFinishRequest {		let registration_finish_request = RegistrationFinishRequest {
session_id: registration_start_response.session_id,		session_id: registration_start_response.session_id,
opaque_registration_upload,		opaque_registration_upload,
};		};

let registration_finish_response = identity_client		let registration_finish_response = identity_client
.register_password_user_finish(registration_finish_request)		.register_password_user_finish(registration_finish_request)
.await?		.await?
.into_inner();		.into_inner();
let user_id_and_access_token = UserIDAndDeviceAccessToken {		let user_id_and_access_token = UserIDAndDeviceAccessToken {
user_id: registration_finish_response.user_id,		user_id: registration_finish_response.user_id,
access_token: registration_finish_response.access_token,		access_token: registration_finish_response.access_token,
};		};
Ok(serde_json::to_string(&user_id_and_access_token)?)		Ok(serde_json::to_string(&user_id_and_access_token)?)
}		}

#[instrument]		#[instrument]
fn identity_login_user_pake_blocking(		fn login_password_user(
client: Box<IdentityClient>,
username: String,		username: String,
password: String,		password: String,
key_payload: String,		key_payload: String,
key_payload_signature: String,		key_payload_signature: String,
identity_prekey: String,		content_prekey: String,
identity_prekey_signature: String,		content_prekey_signature: String,
notif_prekey: String,		notif_prekey: String,
notif_prekey_signature: String,		notif_prekey_signature: String,
identity_onetime_keys: Vec<String>,		content_onetime_keys: Vec<String>,
notif_onetime_keys: Vec<String>,		notif_onetime_keys: Vec<String>,
) -> Result<String, Status> {		promise_id: u32,
RUNTIME.block_on(identity_client::login_user_pake(		) {
client,		RUNTIME.spawn(async move {
		let password_user_info = PasswordUserInfo {
username,		username,
password,		password,
key_payload,		key_payload,
key_payload_signature,		key_payload_signature,
identity_prekey,		content_prekey,
identity_prekey_signature,		content_prekey_signature,
notif_prekey,		notif_prekey,
notif_prekey_signature,		notif_prekey_signature,
identity_onetime_keys,		content_onetime_keys,
notif_onetime_keys,		notif_onetime_keys,
))		};
		let result = login_password_user_helper(password_user_info).await;
		handle_string_result_as_callback(result, promise_id);
		});
		}

		async fn login_password_user_helper(
		password_user_info: PasswordUserInfo,
		) -> Result<String, Error> {
		let mut client_login = Login::new();
		let opaque_login_request = client_login
		.start(&password_user_info.password)
		.map_err(handle_error)?;
		let login_start_request = OpaqueLoginStartRequest {
		opaque_login_request,
		username: password_user_info.username,
		device_key_upload: Some(DeviceKeyUpload {
		device_key_info: Some(IdentityKeyInfo {
		payload: password_user_info.key_payload,
		payload_signature: password_user_info.key_payload_signature,
		social_proof: None,
		}),
		content_upload: Some(PreKey {
		pre_key: password_user_info.content_prekey,
		pre_key_signature: password_user_info.content_prekey_signature,
		}),
		notif_upload: Some(PreKey {
		pre_key: password_user_info.notif_prekey,
		pre_key_signature: password_user_info.notif_prekey_signature,
		}),
		onetime_content_prekeys: password_user_info.content_onetime_keys,
		onetime_notif_prekeys: password_user_info.notif_onetime_keys,
		}),
		};

		let mut identity_client =
		IdentityClientServiceClient::connect("http://127.0.0.1:50054").await?;
		let login_start_response = identity_client
		.login_password_user_start(login_start_request)
		.await?
		.into_inner();

		let opaque_login_upload = client_login
		.finish(&login_start_response.opaque_login_response)
		.map_err(handle_error)?;
		let login_finish_request = OpaqueLoginFinishRequest {
		session_id: login_start_response.session_id,
		opaque_login_upload,
		};

		let login_finish_response = identity_client
		.login_password_user_finish(login_finish_request)
		.await?
		.into_inner();
		let user_id_and_access_token = UserIDAndDeviceAccessToken {
		user_id: login_finish_response.user_id,
		access_token: login_finish_response.access_token,
		};
		Ok(serde_json::to_string(&user_id_and_access_token)?)
}		}

#[instrument]		#[instrument]
fn identity_login_user_wallet_blocking(		fn identity_login_user_wallet_blocking(
client: Box<IdentityClient>,		client: Box<IdentityClient>,
siwe_message: String,		siwe_message: String,
siwe_signature: String,		siwe_signature: String,
key_payload: String,		key_payload: String,
Show All 34 Lines