Details

ginsu retitled this revision from DRAFT [landing] introduce keybase competitor data to [landing] introduce keybase competitor data.Jul 10 2023, 1:14 PM

ginsu edited the summary of this revision. (Show Details)

ginsu edited the test plan for this revision. (Show Details)

ginsu added reviewers: atul, kamil.

ginsu attached a referenced file: F630521: Screenshot 2023-07-07 at 4.25.28 PM.png. (Show Details)

ginsu attached a referenced file: F630522: Screenshot 2023-07-07 at 4.25.24 PM.png. (Show Details)

Harbormaster completed remote builds in B20854: Diff 28562.Jul 10 2023, 1:27 PM

Please use rsquo for all apostrophes, and make sure you adjust the whole competitor-data.js file to reflect that

use rsquo

Harbormaster completed remote builds in B20856: Diff 28564.Jul 10 2023, 2:58 PM

Please use rsquo for all apostrophes, and make sure you adjust the whole competitor-data.js file to reflect that

I wonder if there's some way to use ' and " throughout the codebase and have "smart quotes" be part of some sort of styling or "rendering" step?

atul accepted this revision.Jul 16 2023, 11:25 PM

atul added inline comments.

landing/competitor-data.js
122	This is more of a copy-related thing, so outside of the purview of code review, but it could be a little confusing that we mention "Signal’s Double Ratchet algorithm" in this block and "Comm uses Matrix.org’s implementation of Double Ratchet" in the `commDescriptionLong` block below. Wonder if we should make it clear that we're using "Matrix.org's implementation of Signal's Double Ratchet algorithm" in this block to clarify things? Might be too verbose, just a thought. (cc @ashoat, but feel free to disregard if copy has been finalized)
124	Is "most apps" referring to Most apps generally Most messaging apps Most E2E encrypted messaging apps ? Probably pretty clear that it's (3) given context clues, but wonder if it should be specified? (cc @ashoat, but feel free to disregard if copy has been finalized)

This revision is now accepted and ready to land.Jul 16 2023, 11:25 PM

ashoat added inline comments.Jul 17 2023, 5:59 AM

landing/competitor-data.js
122	@ginsu brought this up too... I get how it feels ambiguous, but it's correct. I don't think bringing up Matrix.org in this context is super helpful... it clarifies things for somebody who is super deeply in the know, but for somebody who isn't aware of Matrix.org or Olm (great majority of people) I think it will lead to confusion Although hmmm what if we tried to make it more clear that Signal didn't implement the code we use here? Something like: Comm uses the Double Ratchet algorithm. Pioneered by Signal, Double Ratchet is the industry standard for E2E encryption.
124	We can modify this to say "most E2E-encrypted messaging apps" if there's space

updated copy still works and looks great! will update diff momentarily with these new changes

landing/competitor-data.js
122
124

ginsu attached a referenced file: F641677: Screenshot 2023-07-17 at 1.53.38 PM.png. (Show Details)Jul 17 2023, 10:55 AM

ginsu attached a referenced file: F641676: Screenshot 2023-07-17 at 1.53.58 PM.png. (Show Details)

update copy

Harbormaster completed remote builds in B20980: Diff 28763.Jul 17 2023, 11:14 AM

change long description type from string to $ReadOnlyArray<string>. D8537 introduces logic to the CompetitorFeature so that it can handle multiple paragraphs in the long descriptions.

Harbormaster completed remote builds in B21003: Diff 28793.Jul 18 2023, 2:25 PM

update double quote character

Harbormaster completed remote builds in B21516: Diff 29513.Aug 3 2023, 12:07 PM

rebase before landing

Harbormaster completed remote builds in B21622: Diff 29668.Aug 8 2023, 1:18 PM

Closed by commit rCOMM26bd8d289c86: [landing] introduce keybase competitor data (authored by ginsu). · Explain WhyAug 8 2023, 2:08 PM

This revision was automatically updated to reflect the committed changes.

ginsu added a commit: rCOMM26bd8d289c86: [landing] introduce keybase competitor data.

Diff 28564

View Options

landing/competitor-data.js

This file was copied to native/cpp/CommonCpp/grpc/grpc_client/src/identity_client.rs.

	use lazy_static::lazy_static;			use lazy_static::lazy_static;
	use opaque_ke::{
	ClientLogin, ClientLoginFinishParameters, ClientLoginStartParameters,
	ClientLoginStartResult, ClientRegistration,
	ClientRegistrationFinishParameters, CredentialFinalization,
	CredentialResponse, RegistrationResponse, RegistrationUpload,
	};
	use rand::{rngs::OsRng, CryptoRng, Rng};
	use std::sync::Arc;			use std::sync::Arc;
	use tokio::runtime::{Builder, Runtime};			use tokio::runtime::{Builder, Runtime};
	use tokio::sync::mpsc;
	use tokio_stream::wrappers::ReceiverStream;
	use tonic::{transport::Channel, Request, Status};
	use tracing::{error, instrument};

				pub mod identity_client;
	mod opaque;			mod opaque;
	use opaque::Cipher;

	use crate::identity::{
	identity_service_client::IdentityServiceClient,
	login_request::Data::PakeLoginRequest,
	login_request::Data::WalletLoginRequest,
	login_response::Data::PakeLoginResponse as LoginPakeLoginResponse,
	login_response::Data::WalletLoginResponse,
	pake_login_request::Data::PakeCredentialFinalization as LoginPakeCredentialFinalization,
	pake_login_request::Data::PakeCredentialRequestAndUserId,
	pake_login_response::Data::AccessToken,
	pake_login_response::Data::PakeCredentialResponse,
	registration_request::Data::PakeCredentialFinalization as RegistrationPakeCredentialFinalization,
	registration_request::Data::PakeRegistrationRequestAndUserId,
	registration_request::Data::PakeRegistrationUploadAndCredentialRequest,
	registration_response::Data::PakeLoginResponse as RegistrationPakeLoginResponse,
	registration_response::Data::PakeRegistrationResponse, GetUserIdRequest,
	LoginRequest, LoginResponse,
	PakeCredentialRequestAndUserId as PakeCredentialRequestAndUserIdStruct,
	PakeLoginRequest as PakeLoginRequestStruct,
	PakeLoginResponse as PakeLoginResponseStruct,
	PakeRegistrationRequestAndUserId as PakeRegistrationRequestAndUserIdStruct,
	PakeRegistrationUploadAndCredentialRequest as PakeRegistrationUploadAndCredentialRequestStruct,
	RegistrationRequest, RegistrationResponse as RegistrationResponseMessage,
	VerifyUserTokenRequest, WalletLoginRequest as WalletLoginRequestStruct,
	WalletLoginResponse as WalletLoginResponseStruct,
	};
	pub mod identity {			pub mod identity {
	tonic::include_proto!("identity");			tonic::include_proto!("identity");
	}			}

	const IDENTITY_SERVICE_SOCKET_ADDR: &str = "https://[::1]:50051";			const IDENTITY_SERVICE_SOCKET_ADDR: &str = "https://[::1]:50051";

	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)
	.enable_all()			.enable_all()
	.build()			.build()
	.unwrap()			.unwrap()
	);			);
	}			}

	#[cxx::bridge(namespace = "identity")]
	mod ffi {
	extern "Rust" {
	type Client;
	fn initialize_client() -> Box<Client>;
	fn get_user_id_blocking(
	client: Box<Client>,
	auth_type: i32,
	user_info: String,
	) -> Result<String>;
	fn verify_user_token_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	access_token: String,
	) -> Result<bool>;
	fn register_user_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	username: String,
	password: String,
	user_public_key: String,
	) -> Result<String>;
	fn login_user_pake_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	password: String,
	) -> Result<String>;
	fn login_user_wallet_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	siwe_message: String,
	siwe_signature: Vec<u8>,
	user_public_key: String,
	) -> Result<String>;
	}
	}

	#[derive(Debug)]
	struct Client {
	identity_client: IdentityServiceClient<Channel>,
	}

	fn initialize_client() -> Box<Client> {
	Box::new(Client {
	identity_client: RUNTIME
	.block_on(IdentityServiceClient::connect(IDENTITY_SERVICE_SOCKET_ADDR))
	.unwrap(),
	})
	}

	async fn get_user_id(
	mut client: Box<Client>,
	auth_type: i32,
	user_info: String,
	) -> Result<String, Status> {
	Ok(
	client
	.identity_client
	.get_user_id(GetUserIdRequest {
	auth_type,
	user_info,
	})
	.await?
	.into_inner()
	.user_id,
	)
	}

	#[instrument]
	fn get_user_id_blocking(
	client: Box<Client>,
	auth_type: i32,
	user_info: String,
	) -> Result<String, Status> {
	RUNTIME.block_on(get_user_id(client, auth_type, user_info))
	}

	async fn verify_user_token(
	mut client: Box<Client>,
	user_id: String,
	device_id: String,
	access_token: String,
	) -> Result<bool, Status> {
	Ok(
	client
	.identity_client
	.verify_user_token(VerifyUserTokenRequest {
	user_id,
	device_id,
	access_token,
	})
	.await?
	.into_inner()
	.token_valid,
	)
	}

	#[instrument]
	fn verify_user_token_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	access_token: String,
	) -> Result<bool, Status> {
	RUNTIME.block_on(verify_user_token(client, user_id, device_id, access_token))
	}

	async fn register_user(
	mut client: Box<Client>,
	user_id: String,
	device_id: String,
	username: String,
	password: String,
	user_public_key: String,
	) -> Result<String, Status> {
	// Create a RegistrationRequest channel and use ReceiverStream to turn the
	// MPSC receiver into a Stream for outbound messages
	let (tx, rx) = mpsc::channel(1);
	let stream = ReceiverStream::new(rx);
	let request = Request::new(stream);

	// `response` is the Stream for inbound messages
	let mut response = client
	.identity_client
	.register_user(request)
	.await?
	.into_inner();

	// Start PAKE registration on client and send initial registration request
	// to Identity service
	let mut client_rng = OsRng;
	let (registration_request, client_registration) = pake_registration_start(
	&mut client_rng,
	user_id,
	&password,
	device_id,
	username,
	user_public_key,
	)?;
	if let Err(e) = tx.send(registration_request).await {
	error!("Response was dropped: {}", e);
	return Err(Status::aborted("Dropped response"));
	}

	// Handle responses from Identity service sequentially, making sure we get
	// messages in the correct order

	// Finish PAKE registration and begin PAKE login; send the final
	// registration request and initial login request together to reduce the
	// number of trips
	let message = response.message().await?;
	let client_login = handle_registration_response(
	message,
	&mut client_rng,
	client_registration,
	&password,
	tx.clone(),
	)
	.await?;

	// Finish PAKE login; send final login request to Identity service
	let message = response.message().await?;
	handle_registration_credential_response(message, client_login, tx).await?;

	// Return access token
	let message = response.message().await?;
	handle_registration_token_response(message)
	}

	#[instrument]
	fn register_user_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	username: String,
	password: String,
	user_public_key: String,
	) -> Result<String, Status> {
	RUNTIME.block_on(register_user(
	client,
	user_id,
	device_id,
	username,
	password,
	user_public_key,
	))
	}

	async fn login_user_pake(
	mut client: Box<Client>,
	user_id: String,
	device_id: String,
	password: String,
	) -> Result<String, Status> {
	// Create a LoginRequest channel and use ReceiverStream to turn the
	// MPSC receiver into a Stream for outbound messages
	let (tx, rx) = mpsc::channel(1);
	let stream = ReceiverStream::new(rx);
	let request = Request::new(stream);

	// `response` is the Stream for inbound messages
	let mut response = client
	.identity_client
	.login_user(request)
	.await?
	.into_inner();

	// Start PAKE login on client and send initial login request to Identity
	// service
	let mut client_rng = OsRng;
	let client_login_start_result = pake_login_start(&mut client_rng, &password)?;
	let login_request = LoginRequest {
	data: Some(PakeLoginRequest(PakeLoginRequestStruct {
	data: Some(PakeCredentialRequestAndUserId(
	PakeCredentialRequestAndUserIdStruct {
	user_id,
	device_id,
	pake_credential_request: client_login_start_result
	.message
	.serialize()
	.map_err(\|e\| {
	error!("Could not serialize credential request: {}", e);
	Status::failed_precondition("PAKE failure")
	})?,
	},
	)),
	})),
	};
	if let Err(e) = tx.send(login_request).await {
	error!("Response was dropped: {}", e);
	return Err(Status::aborted("Dropped response"));
	}

	// Handle responses from Identity service sequentially, making sure we get
	// messages in the correct order

	// Finish PAKE login; send final login request to Identity service
	let message = response.message().await?;
	handle_login_credential_response(
	message,
	client_login_start_result.state,
	tx,
	)
	.await?;

	// Return access token
	let message = response.message().await?;
	handle_login_token_response(message)
	}

	#[instrument]
	fn login_user_pake_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	password: String,
	) -> Result<String, Status> {
	RUNTIME.block_on(login_user_pake(client, user_id, device_id, password))
	}

	async fn login_user_wallet(
	mut client: Box<Client>,
	user_id: String,
	device_id: String,
	siwe_message: String,
	siwe_signature: Vec<u8>,
	user_public_key: String,
	) -> Result<String, Status> {
	// Create a LoginRequest channel and use ReceiverStream to turn the
	// MPSC receiver into a Stream for outbound messages
	let (tx, rx) = mpsc::channel(1);
	let stream = ReceiverStream::new(rx);
	let request = Request::new(stream);

	// `response` is the Stream for inbound messages
	let mut response = client
	.identity_client
	.login_user(request)
	.await?
	.into_inner();

	// Start wallet login on client and send initial login request to Identity
	// service
	let login_request = LoginRequest {
	data: Some(WalletLoginRequest(WalletLoginRequestStruct {
	user_id,
	device_id,
	siwe_message,
	siwe_signature,
	user_public_key,
	})),
	};
	if let Err(e) = tx.send(login_request).await {
	error!("Response was dropped: {}", e);
	return Err(Status::aborted("Dropped response"));
	}

	// Return access token
	let message = response.message().await?;
	handle_wallet_login_response(message)
	}

	#[instrument]
	fn login_user_wallet_blocking(
	client: Box<Client>,
	user_id: String,
	device_id: String,
	siwe_message: String,
	siwe_signature: Vec<u8>,
	user_public_key: String,
	) -> Result<String, Status> {
	RUNTIME.block_on(login_user_wallet(
	client,
	user_id,
	device_id,
	siwe_message,
	siwe_signature,
	user_public_key,
	))
	}

	fn pake_registration_start(
	rng: &mut (impl Rng + CryptoRng),
	user_id: String,
	password: &str,
	device_id: String,
	username: String,
	user_public_key: String,
	) -> Result<(RegistrationRequest, ClientRegistration<Cipher>), Status> {
	let client_registration_start_result =
	ClientRegistration::<Cipher>::start(rng, password.as_bytes()).map_err(
	\|e\| {
	error!("Failed to start PAKE registration: {}", e);
	Status::failed_precondition("PAKE failure")
	},
	)?;
	let pake_registration_request =
	client_registration_start_result.message.serialize();
	Ok((
	RegistrationRequest {
	data: Some(PakeRegistrationRequestAndUserId(
	PakeRegistrationRequestAndUserIdStruct {
	user_id,
	device_id,
	pake_registration_request,
	username,
	user_public_key,
	},
	)),
	},
	client_registration_start_result.state,
	))
	}

	fn pake_registration_finish(
	rng: &mut (impl Rng + CryptoRng),
	registration_response_bytes: &[u8],
	client_registration: ClientRegistration<Cipher>,
	) -> Result<RegistrationUpload<Cipher>, Status> {
	client_registration
	.finish(
	rng,
	RegistrationResponse::deserialize(registration_response_bytes).map_err(
	\|e\| {
	error!("Could not deserialize registration response bytes: {}", e);
	Status::aborted("Invalid response bytes")
	},
	)?,
	ClientRegistrationFinishParameters::default(),
	)
	.map_err(\|e\| {
	error!("Failed to finish PAKE registration: {}", e);
	Status::aborted("PAKE failure")
	})
	.map(\|res\| res.message)
	}

	fn pake_login_start(
	rng: &mut (impl Rng + CryptoRng),
	password: &str,
	) -> Result<ClientLoginStartResult<Cipher>, Status> {
	ClientLogin::<Cipher>::start(
	rng,
	password.as_bytes(),
	ClientLoginStartParameters::default(),
	)
	.map_err(\|e\| {
	error!("Failed to start PAKE login: {}", e);
	Status::failed_precondition("PAKE failure")
	})
	}

	fn pake_login_finish(
	credential_response_bytes: &[u8],
	client_login: ClientLogin<Cipher>,
	) -> Result<CredentialFinalization<Cipher>, Status> {
	client_login
	.finish(
	CredentialResponse::deserialize(credential_response_bytes).map_err(
	\|e\| {
	error!("Could not deserialize credential response bytes: {}", e);
	Status::aborted("Invalid response bytes")
	},
	)?,
	ClientLoginFinishParameters::default(),
	)
	.map_err(\|e\| {
	error!("Failed to finish PAKE login: {}", e);
	Status::aborted("PAKE failure")
	})
	.map(\|res\| res.message)
	}

	fn handle_unexpected_response<T: std::fmt::Debug>(
	message: Option<T>,
	) -> Status {
	error!("Received an unexpected message: {:?}", message);
	Status::invalid_argument("Invalid response data")
	}

	async fn handle_registration_response(
	message: Option<RegistrationResponseMessage>,
	client_rng: &mut (impl Rng + CryptoRng),
	client_registration: ClientRegistration<Cipher>,
	password: &str,
	tx: mpsc::Sender<RegistrationRequest>,
	) -> Result<ClientLogin<Cipher>, Status> {
	if let Some(RegistrationResponseMessage {
	data: Some(PakeRegistrationResponse(registration_response_bytes)),
	..
	}) = message
	{
	let pake_registration_upload = pake_registration_finish(
	client_rng,
	&registration_response_bytes,
	client_registration,
	)?
	.serialize();
	let client_login_start_result = pake_login_start(client_rng, password)?;

	// `registration_request` is a gRPC message containing serialized bytes to
	// complete PAKE registration and begin PAKE login
	let registration_request = RegistrationRequest {
	data: Some(PakeRegistrationUploadAndCredentialRequest(
	PakeRegistrationUploadAndCredentialRequestStruct {
	pake_registration_upload,
	pake_credential_request: client_login_start_result
	.message
	.serialize()
	.map_err(\|e\| {
	error!("Could not serialize credential request: {}", e);
	Status::failed_precondition("PAKE failure")
	})?,
	},
	)),
	};
	if let Err(e) = tx.send(registration_request).await {
	error!("Response was dropped: {}", e);
	return Err(Status::aborted("Dropped response"));
	}
	Ok(client_login_start_result.state)
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	async fn handle_registration_credential_response(
	message: Option<RegistrationResponseMessage>,
	client_login: ClientLogin<Cipher>,
	tx: mpsc::Sender<RegistrationRequest>,
	) -> Result<(), Status> {
	if let Some(RegistrationResponseMessage {
	data:
	Some(RegistrationPakeLoginResponse(PakeLoginResponseStruct {
	data: Some(PakeCredentialResponse(credential_response_bytes)),
	})),
	}) = message
	{
	let registration_request = RegistrationRequest {
	data: Some(RegistrationPakeCredentialFinalization(
	pake_login_finish(&credential_response_bytes, client_login)?
	.serialize()
	.map_err(\|e\| {
	error!("Could not serialize credential request: {}", e);
	Status::failed_precondition("PAKE failure")
	})?,
	)),
	};
	send_to_mpsc(tx, registration_request).await
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	async fn handle_login_credential_response(
	message: Option<LoginResponse>,
	client_login: ClientLogin<Cipher>,
	tx: mpsc::Sender<LoginRequest>,
	) -> Result<(), Status> {
	if let Some(LoginResponse {
	data:
	Some(LoginPakeLoginResponse(PakeLoginResponseStruct {
	data: Some(PakeCredentialResponse(credential_response_bytes)),
	})),
	}) = message
	{
	let login_request = LoginRequest {
	data: Some(PakeLoginRequest(PakeLoginRequestStruct {
	data: Some(LoginPakeCredentialFinalization(
	pake_login_finish(&credential_response_bytes, client_login)?
	.serialize()
	.map_err(\|e\| {
	error!("Could not serialize credential request: {}", e);
	Status::failed_precondition("PAKE failure")
	})?,
	)),
	})),
	};
	send_to_mpsc(tx, login_request).await
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	fn handle_registration_token_response(
	message: Option<RegistrationResponseMessage>,
	) -> Result<String, Status> {
	if let Some(RegistrationResponseMessage {
	data:
	Some(RegistrationPakeLoginResponse(PakeLoginResponseStruct {
	data: Some(AccessToken(access_token)),
	})),
	}) = message
	{
	Ok(access_token)
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	fn handle_login_token_response(
	message: Option<LoginResponse>,
	) -> Result<String, Status> {
	if let Some(LoginResponse {
	data:
	Some(LoginPakeLoginResponse(PakeLoginResponseStruct {
	data: Some(AccessToken(access_token)),
	})),
	}) = message
	{
	Ok(access_token)
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	fn handle_wallet_login_response(
	message: Option<LoginResponse>,
	) -> Result<String, Status> {
	if let Some(LoginResponse {
	data: Some(WalletLoginResponse(WalletLoginResponseStruct { access_token })),
	}) = message
	{
	Ok(access_token)
	} else {
	Err(handle_unexpected_response(message))
	}
	}

	async fn send_to_mpsc<T>(
	tx: mpsc::Sender<T>,
	request: T,
	) -> Result<(), Status> {
	if let Err(e) = tx.send(request).await {
	error!("Response was dropped: {}", e);
	return Err(Status::aborted("Dropped response"));
	}
	Ok(())
	}

[landing] introduce keybase competitor data
ClosedPublic
Actions

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 28564

landing/competitor-data.js

[landing] introduce keybase competitor dataClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 28564

landing/competitor-data.js

[landing] introduce keybase competitor data
ClosedPublic
Actions

Revision Contents
Changeset List