Page MenuHomePhabricator
Differential D11719

[web/lib] add sequential decrypt to `olmAPI`
ClosedPublic
Actions

Authored by kamil on Apr 22 2024, 3:42 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 13, 10:18 PM
Unknown Object (File)
Fri, Mar 7, 1:44 AM
Unknown Object (File)
Fri, Mar 7, 1:41 AM
Unknown Object (File)
Mar 5 2025, 10:24 PM
Unknown Object (File)
Mar 5 2025, 6:51 PM
Unknown Object (File)
Feb 25 2025, 5:35 AM
Unknown Object (File)
Feb 22 2025, 11:31 AM
Unknown Object (File)
Feb 22 2025, 11:31 AM
View All 73 Files
Subscribers
ashoat

Details

Reviewers
tomek
marcin
Commits
rCOMMa14e4c1d5e9a: [web/lib] add sequential decrypt to `olmAPI`
Summary

Binding to olm method to sequential decrypt. Implementing different because this method will also be responsible for persisting message in SQLite (added later in the stack).

Depends on D11718

Test Plan

Created session between two web clients:

  1. Sending couple of encrypted messsages
  2. Sending messages with wrong order -> OLM_MESSAGE_OUT_OF_ORDER
  3. Sending the same message multiple times -> OLM_ALREADY_DECRYPTED_OR_KEYS_SKIPPED

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

kamil created this revision.Apr 22 2024, 3:42 PM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptApr 22 2024, 3:42 PM
kamil added a child revision: D11720: [lib] update P2P message handler to use sequential decrypt.Apr 22 2024, 3:53 PM
Harbormaster completed remote builds in B28376: Diff 39370.Apr 22 2024, 4:01 PM
kamil added inline comments.Apr 22 2024, 5:21 PM
web/shared-worker/worker/worker-crypto.js
470 ↗(On Diff #39370)

mistake while rebasing

kamil added inline comments.Apr 23 2024, 5:27 AM
web/shared-worker/worker/worker-crypto.js
459 ↗(On Diff #39370)

removed in D11728

kamil published this revision for review.Apr 23 2024, 6:38 AM
marcin accepted this revision.Apr 24 2024, 3:11 AM
This revision is now accepted and ready to land.Apr 24 2024, 3:11 AM
kamil updated this revision to Diff 39612.Apr 29 2024, 12:48 AM

decrypt -> decrypt_sequential

Harbormaster completed remote builds in B28555: Diff 39612.Apr 29 2024, 1:04 AM
Closed by commit rCOMMa14e4c1d5e9a: [web/lib] add sequential decrypt to `olmAPI` (authored by kamil). · Explain WhyApr 29 2024, 1:11 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMMa14e4c1d5e9a: [web/lib] add sequential decrypt to `olmAPI`.

Revision Contents
Changeset List

PathSize
lib/
types/
5 lines
utils/
__mocks__/
1 line
native/
crypto/
1 line
web/
crypto/
1 line
shared-worker/
worker/
24 lines

Diff 39617

View Options

lib/types/crypto-types.js

use backup_client::{ use backup_client::{
BackupClient, BackupData, BackupDescriptor, RequestedData, BackupClient, BackupData, BackupDescriptor, RequestedData,
}; };
use bytesize::ByteSize; use bytesize::ByteSize;
use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse}; use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse};
use commtest::identity::device::register_user_device;
use commtest::{ use commtest::{
service_addr, service_addr,
tools::{generate_stable_nbytes, obtain_number_of_threads, Error}, tools::{generate_stable_nbytes, obtain_number_of_threads, Error},
}; };
use grpc_clients::identity::DeviceType;
use tokio::{runtime::Runtime, task::JoinSet}; use tokio::{runtime::Runtime, task::JoinSet};
#[tokio::test] #[tokio::test]
async fn backup_performance_test() -> Result<(), Error> { async fn backup_performance_test() -> Result<(), Error> {
let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?; let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
let number_of_threads = obtain_number_of_threads(); let number_of_threads = obtain_number_of_threads();
Show All 16 Lines backup_data.push(BackupData {
ByteSize::mib(4).as_u64() as usize, ByteSize::mib(4).as_u64() as usize,
Some(i as u8), Some(i as u8),
), ),
attachments: vec![], attachments: vec![],
siwe_backup_msg: None, siwe_backup_msg: None,
}); });
} }
let device_info_1 = register_user_device(None, Some(DeviceType::Ios)).await;
let device_info_2 = register_user_device(None, Some(DeviceType::Ios)).await;
let user_identities = [ let user_identities = [
UserIdentity { UserIdentity {
user_id: "1".to_string(), user_id: device_info_1.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_1.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_1.device_id,
}, },
UserIdentity { UserIdentity {
user_id: "2".to_string(), user_id: device_info_2.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_2.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_2.device_id,
}, },
]; ];
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
println!("Creating new backups"); println!("Creating new backups");
rt.block_on(async { rt.block_on(async {
let mut set = JoinSet::new(); let mut set = JoinSet::new();
for (i, item) in backup_data.iter().cloned().enumerate() { for (i, item) in backup_data.iter().cloned().enumerate() {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines
View Options

lib/utils/__mocks__/config.js

use backup_client::{ use backup_client::{
BackupClient, BackupData, BackupDescriptor, RequestedData, BackupClient, BackupData, BackupDescriptor, RequestedData,
}; };
use bytesize::ByteSize; use bytesize::ByteSize;
use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse}; use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse};
use commtest::identity::device::register_user_device;
use commtest::{ use commtest::{
service_addr, service_addr,
tools::{generate_stable_nbytes, obtain_number_of_threads, Error}, tools::{generate_stable_nbytes, obtain_number_of_threads, Error},
}; };
use grpc_clients::identity::DeviceType;
use tokio::{runtime::Runtime, task::JoinSet}; use tokio::{runtime::Runtime, task::JoinSet};
#[tokio::test] #[tokio::test]
async fn backup_performance_test() -> Result<(), Error> { async fn backup_performance_test() -> Result<(), Error> {
let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?; let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
let number_of_threads = obtain_number_of_threads(); let number_of_threads = obtain_number_of_threads();
Show All 16 Lines backup_data.push(BackupData {
ByteSize::mib(4).as_u64() as usize, ByteSize::mib(4).as_u64() as usize,
Some(i as u8), Some(i as u8),
), ),
attachments: vec![], attachments: vec![],
siwe_backup_msg: None, siwe_backup_msg: None,
}); });
} }
let device_info_1 = register_user_device(None, Some(DeviceType::Ios)).await;
let device_info_2 = register_user_device(None, Some(DeviceType::Ios)).await;
let user_identities = [ let user_identities = [
UserIdentity { UserIdentity {
user_id: "1".to_string(), user_id: device_info_1.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_1.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_1.device_id,
}, },
UserIdentity { UserIdentity {
user_id: "2".to_string(), user_id: device_info_2.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_2.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_2.device_id,
}, },
]; ];
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
println!("Creating new backups"); println!("Creating new backups");
rt.block_on(async { rt.block_on(async {
let mut set = JoinSet::new(); let mut set = JoinSet::new();
for (i, item) in backup_data.iter().cloned().enumerate() { for (i, item) in backup_data.iter().cloned().enumerate() {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines
View Options

native/crypto/olm-api.js

use backup_client::{ use backup_client::{
BackupClient, BackupData, BackupDescriptor, RequestedData, BackupClient, BackupData, BackupDescriptor, RequestedData,
}; };
use bytesize::ByteSize; use bytesize::ByteSize;
use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse}; use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse};
use commtest::identity::device::register_user_device;
use commtest::{ use commtest::{
service_addr, service_addr,
tools::{generate_stable_nbytes, obtain_number_of_threads, Error}, tools::{generate_stable_nbytes, obtain_number_of_threads, Error},
}; };
use grpc_clients::identity::DeviceType;
use tokio::{runtime::Runtime, task::JoinSet}; use tokio::{runtime::Runtime, task::JoinSet};
#[tokio::test] #[tokio::test]
async fn backup_performance_test() -> Result<(), Error> { async fn backup_performance_test() -> Result<(), Error> {
let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?; let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
let number_of_threads = obtain_number_of_threads(); let number_of_threads = obtain_number_of_threads();
Show All 16 Lines backup_data.push(BackupData {
ByteSize::mib(4).as_u64() as usize, ByteSize::mib(4).as_u64() as usize,
Some(i as u8), Some(i as u8),
), ),
attachments: vec![], attachments: vec![],
siwe_backup_msg: None, siwe_backup_msg: None,
}); });
} }
let device_info_1 = register_user_device(None, Some(DeviceType::Ios)).await;
let device_info_2 = register_user_device(None, Some(DeviceType::Ios)).await;
let user_identities = [ let user_identities = [
UserIdentity { UserIdentity {
user_id: "1".to_string(), user_id: device_info_1.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_1.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_1.device_id,
}, },
UserIdentity { UserIdentity {
user_id: "2".to_string(), user_id: device_info_2.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_2.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_2.device_id,
}, },
]; ];
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
println!("Creating new backups"); println!("Creating new backups");
rt.block_on(async { rt.block_on(async {
let mut set = JoinSet::new(); let mut set = JoinSet::new();
for (i, item) in backup_data.iter().cloned().enumerate() { for (i, item) in backup_data.iter().cloned().enumerate() {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines
View Options

web/crypto/olm-api.js

use backup_client::{ use backup_client::{
BackupClient, BackupData, BackupDescriptor, RequestedData, BackupClient, BackupData, BackupDescriptor, RequestedData,
}; };
use bytesize::ByteSize; use bytesize::ByteSize;
use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse}; use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse};
use commtest::identity::device::register_user_device;
use commtest::{ use commtest::{
service_addr, service_addr,
tools::{generate_stable_nbytes, obtain_number_of_threads, Error}, tools::{generate_stable_nbytes, obtain_number_of_threads, Error},
}; };
use grpc_clients::identity::DeviceType;
use tokio::{runtime::Runtime, task::JoinSet}; use tokio::{runtime::Runtime, task::JoinSet};
#[tokio::test] #[tokio::test]
async fn backup_performance_test() -> Result<(), Error> { async fn backup_performance_test() -> Result<(), Error> {
let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?; let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
let number_of_threads = obtain_number_of_threads(); let number_of_threads = obtain_number_of_threads();
Show All 16 Lines backup_data.push(BackupData {
ByteSize::mib(4).as_u64() as usize, ByteSize::mib(4).as_u64() as usize,
Some(i as u8), Some(i as u8),
), ),
attachments: vec![], attachments: vec![],
siwe_backup_msg: None, siwe_backup_msg: None,
}); });
} }
let device_info_1 = register_user_device(None, Some(DeviceType::Ios)).await;
let device_info_2 = register_user_device(None, Some(DeviceType::Ios)).await;
let user_identities = [ let user_identities = [
UserIdentity { UserIdentity {
user_id: "1".to_string(), user_id: device_info_1.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_1.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_1.device_id,
}, },
UserIdentity { UserIdentity {
user_id: "2".to_string(), user_id: device_info_2.user_id.clone(),
access_token: "dummy access token".to_string(), access_token: device_info_2.access_token,
device_id: "dummy device_id".to_string(), device_id: device_info_2.device_id,
}, },
]; ];
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
println!("Creating new backups"); println!("Creating new backups");
rt.block_on(async { rt.block_on(async {
let mut set = JoinSet::new(); let mut set = JoinSet::new();
for (i, item) in backup_data.iter().cloned().enumerate() { for (i, item) in backup_data.iter().cloned().enumerate() {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines
View Options

web/shared-worker/worker/worker-crypto.js

Loading...