Stop using key package storage trait

Cargo.toml

@@ -16,7 +16,6 @@ members = [
     "mls-rs-provider-sqlite",
     "mls-rs-codec",
     "mls-rs-codec-derive",
-    "mls-rs-uniffi",
     "mls-rs-uniffi/uniffi-bindgen",
 ]
 
@@ -32,5 +31,4 @@ default-members = [
     "mls-rs-crypto-webcrypto",
     "mls-rs-provider-sqlite",
     "mls-rs-codec",
-    "mls-rs-uniffi",
 ]

mls-rs-core/src/identity.rs

@@ -19,10 +19,11 @@ pub use signing_identity::*;
 #[cfg(feature = "x509")]
 pub use x509::*;
 
-use crate::crypto::SignatureSecretKey;
+use crate::crypto::{CipherSuite, SignatureSecretKey};
 
 #[derive(Clone, Debug, MlsEncode, MlsSize, MlsDecode, PartialEq)]
 pub struct SigningData {
     pub signing_identity: SigningIdentity,
     pub signing_key: SignatureSecretKey,
+    pub cipher_suite: CipherSuite,
 }

mls-rs-ffi/Cargo.toml

@@ -17,6 +17,11 @@ sqlite = ["std", "mls-rs-provider-sqlite/sqlite"]
 sqlite-bundled = ["sqlite", "mls-rs-provider-sqlite/sqlite-bundled"]
 std = ["mls-rs/std", "safer-ffi-gen/std"]
 x509 = ["mls-rs-identity-x509"]
+psk = ["mls-rs/psk"]
+by_ref_proposal = ["mls-rs/by_ref_proposal"]
+custom_proposal = ["mls-rs/custom_proposal"]
+private_message = ["mls-rs/private_message"]
+secret_tree_access = ["mls-rs/secret_tree_access"]
 
 [dependencies]
 mls-rs = { path = "../mls-rs", version = "0.43.0", features = ["ffi"] }

mls-rs-uniffi/src/lib.rs

@@ -384,7 +384,7 @@ impl Client {
     pub async fn generate_key_package_message(&self) -> Result<Message, Error> {
         let message = self
             .inner
-            .generate_key_package_message(Default::default(), Default::default())
+            .generate_key_package()
             .await?;
         Ok(message.into())
     }

mls-rs/benches/group_add.rs

@@ -10,6 +10,7 @@ use mls_rs::{
         SigningIdentity,
     },
     mls_rules::{CommitOptions, DefaultMlsRules},
+    test_utils::TestClient,
     CipherSuite, CipherSuiteProvider, Client, CryptoProvider,
 };
 use mls_rs_crypto_openssl::OpensslCryptoProvider;
@@ -24,7 +25,7 @@ fn bench(c: &mut Criterion) {
     let key_packages = (0..MAX_ADD_COUNT)
         .map(|i| {
             make_client(&format!("bob-{i}"))
-                .generate_key_package_message(Default::default(), Default::default())
+                .generate_key_package()
                 .unwrap()
         })
         .collect::<Vec<_>>();
@@ -58,7 +59,7 @@ fn bench(c: &mut Criterion) {
 criterion::criterion_group!(benches, bench);
 criterion::criterion_main!(benches);
 
-fn make_client(name: &str) -> Client<impl MlsConfig> {
+fn make_client(name: &str) -> TestClient<impl MlsConfig> {
     let crypto_provider = OpensslCryptoProvider::new();
     let cipher_suite = CipherSuite::CURVE25519_AES128;
 
@@ -84,4 +85,5 @@ fn make_client(name: &str) -> Client<impl MlsConfig> {
             cipher_suite,
         )
         .build()
+        .into()
 }

mls-rs/examples/api_1x.rs

@@ -2,18 +2,15 @@
 // Copyright by contributors to this project.
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use std::convert::Infallible;
-
 use mls_rs::{
     client_builder::MlsConfig,
     error::MlsError,
     identity::{
         basic::{BasicCredential, BasicIdentityProvider},
         SigningIdentity,
     },
-    CipherSuite, CipherSuiteProvider, Client, CryptoProvider, ExtensionList, KeyPackageStorage,
+    CipherSuite, CipherSuiteProvider, Client, CryptoProvider, ExtensionList,
 };
-use mls_rs_core::key_package::KeyPackageData;
 
 const CIPHERSUITE: CipherSuite = CipherSuite::CURVE25519_AES128;
 
@@ -25,10 +22,7 @@ fn main() -> Result<(), MlsError> {
     let bob = make_client(crypto_provider.clone(), "bob")?;
 
     // Bob generates key package. We store secrets in memory, no need for any storage.
-    let key_package_generation = bob
-        .key_package_builder(CIPHERSUITE, None)?
-        .valid_for_sec(123)
-        .build()?;
+    let key_package_generation = bob.key_package_builder(None)?.valid_for_sec(123).build()?;
 
     let stored_secrets = key_package_generation.key_package_data;
 
@@ -55,25 +49,6 @@ fn main() -> Result<(), MlsError> {
     Ok(())
 }
 
-#[derive(Clone)]
-struct NoOpKeyPackageStorage;
-
-impl KeyPackageStorage for NoOpKeyPackageStorage {
-    type Error = Infallible;
-
-    fn delete(&mut self, _: &[u8]) -> Result<(), Infallible> {
-        Ok(())
-    }
-
-    fn get(&self, _: &[u8]) -> Result<Option<KeyPackageData>, Infallible> {
-        Ok(None)
-    }
-
-    fn insert(&mut self, _: Vec<u8>, _: KeyPackageData) -> Result<(), Infallible> {
-        Ok(())
-    }
-}
-
 fn make_client<P: CryptoProvider + Clone>(
     crypto_provider: P,
     name: &str,
@@ -87,6 +62,5 @@ fn make_client<P: CryptoProvider + Clone>(
         .identity_provider(BasicIdentityProvider)
         .crypto_provider(crypto_provider)
         .signing_identity(signing_identity, secret, CIPHERSUITE)
-        .key_package_repo(NoOpKeyPackageStorage)
         .build())
 }

mls-rs/examples/basic_server_usage.rs

@@ -141,16 +141,18 @@ fn main() -> Result<(), MlsError> {
 
     // Alice creates a group with bob
     let mut alice_group = alice.create_group(ExtensionList::default(), Default::default())?;
-    let bob_key_package =
-        bob.generate_key_package_message(Default::default(), Default::default())?;
+    let bob_key_package = bob.key_package_builder(None)?.build()?;
 
     let welcome = &alice_group
         .commit_builder()
-        .add_member(bob_key_package)?
+        .add_member(bob_key_package.key_package_message)?
         .build()?
         .welcome_messages[0];
 
-    let (mut bob_group, _) = bob.join_group(None, welcome)?;
+    let (mut bob_group, _) = bob
+        .group_joiner(welcome, bob_key_package.key_package_data)?
+        .join()?;
+
     alice_group.apply_pending_commit()?;
 
     // Server starts observing Alice's group

mls-rs/examples/basic_usage.rs

@@ -47,13 +47,12 @@ fn main() -> Result<(), MlsError> {
     let mut alice_group = alice.create_group(ExtensionList::default(), Default::default())?;
 
     // Bob generates a key package that Alice needs to add Bob to the group.
-    let bob_key_package =
-        bob.generate_key_package_message(Default::default(), Default::default())?;
+    let bob_key_package = bob.key_package_builder(None)?.build()?;
 
     // Alice issues a commit that adds Bob to the group.
     let alice_commit = alice_group
         .commit_builder()
-        .add_member(bob_key_package)?
+        .add_member(bob_key_package.key_package_message)?
         .build()?;
 
     // Alice confirms that the commit was accepted by the group so it can be applied locally.
@@ -62,7 +61,12 @@ fn main() -> Result<(), MlsError> {
     alice_group.apply_pending_commit()?;
 
     // Bob joins the group with the welcome message created as part of Alice's commit.
-    let (mut bob_group, _) = bob.join_group(None, &alice_commit.welcome_messages[0])?;
+    let (mut bob_group, _) = bob
+        .group_joiner(
+            &alice_commit.welcome_messages[0],
+            bob_key_package.key_package_data,
+        )?
+        .join()?;
 
     // Alice encrypts an application message to Bob.
     let msg = alice_group.encrypt_application_message(b"hello world", Default::default())?;

mls-rs/examples/custom.rs

@@ -381,27 +381,29 @@ fn main() -> Result<(), CustomError> {
 
     // Alice can add her other device
     let alice_pc_client = make_client(alice_pc)?;
-    let key_package =
-        alice_pc_client.generate_key_package_message(Default::default(), Default::default())?;
+    let key_package = alice_pc_client.key_package_builder(None)?.build()?;
 
     let welcome = alice_tablet_group
         .commit_builder()
-        .add_member(key_package)?
+        .add_member(key_package.key_package_message)?
         .build()?
         .welcome_messages
         .remove(0);
 
     alice_tablet_group.apply_pending_commit()?;
-    let (mut alice_pc_group, _) = alice_pc_client.join_group(None, &welcome)?;
+
+    let (mut alice_pc_group, _) = alice_pc_client
+        .group_joiner(&welcome, key_package.key_package_data)?
+        .join()?;
 
     // Alice cannot add bob's devices yet
     let bob_tablet_client = make_client(bob_tablet)?;
-    let key_package =
-        bob_tablet_client.generate_key_package_message(Default::default(), Default::default())?;
+
+    let key_package = bob_tablet_client.key_package_builder(None)?.build()?;
 
     let res = alice_tablet_group
         .commit_builder()
-        .add_member(key_package.clone())?
+        .add_member(key_package.key_package_message.clone())?
         .build();
 
     assert_matches!(res, Err(MlsError::IdentityProviderError(_)));
@@ -414,10 +416,13 @@ fn main() -> Result<(), CustomError> {
     let commit = alice_tablet_group
         .commit_builder()
         .custom_proposal(add_bob.to_custom_proposal()?)
-        .add_member(key_package)?
+        .add_member(key_package.key_package_message)?
         .build()?;
 
-    bob_tablet_client.join_group(None, &commit.welcome_messages[0])?;
+    bob_tablet_client
+        .group_joiner(&commit.welcome_messages[0], key_package.key_package_data)?
+        .join()?;
+
     alice_tablet_group.apply_pending_commit()?;
     alice_pc_group.process_incoming_message(commit.commit_message)?;
 

mls-rs/examples/large_group.rs

@@ -2,6 +2,7 @@
 // Copyright by contributors to this project.
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+use itertools::Itertools;
 use mls_rs::{
     client_builder::MlsConfig,
     error::MlsError,
@@ -66,15 +67,14 @@ fn make_groups_best_case<P: CryptoProvider + Clone>(
         let bob_client = make_client(crypto_provider.clone(), &make_name(i + 1))?;
 
         // The new client generates a key package.
-        let bob_kpkg =
-            bob_client.generate_key_package_message(Default::default(), Default::default())?;
+        let bob_kpkg = bob_client.key_package_builder(None)?.build()?;
 
         // Last group sends a commit adding the new client to the group.
         let commit = groups
             .last_mut()
             .unwrap()
             .commit_builder()
-            .add_member(bob_kpkg)?
+            .add_member(bob_kpkg.key_package_message)?
             .build()?;
 
         // All other groups process the commit.
@@ -86,7 +86,9 @@ fn make_groups_best_case<P: CryptoProvider + Clone>(
         groups.last_mut().unwrap().apply_pending_commit()?;
 
         // The new member joins.
-        let (bob_group, _info) = bob_client.join_group(None, &commit.welcome_messages[0])?;
+        let (bob_group, _info) = bob_client
+            .group_joiner(&commit.welcome_messages[0], bob_kpkg.key_package_data)?
+            .join()?;
 
         groups.push(bob_group);
     }
@@ -109,11 +111,12 @@ fn make_groups_worst_case<P: CryptoProvider + Clone>(
 
     // Alice adds all Bob's clients in a single commit.
     let mut commit_builder = alice_group.commit_builder();
+    let mut kpkgs = vec![];
 
     for bob_client in &bob_clients {
-        let bob_kpkg =
-            bob_client.generate_key_package_message(Default::default(), Default::default())?;
-        commit_builder = commit_builder.add_member(bob_kpkg)?;
+        let bob_kpkg = bob_client.key_package_builder(None)?.build()?;
+        commit_builder = commit_builder.add_member(bob_kpkg.key_package_message)?;
+        kpkgs.push(bob_kpkg.key_package_data);
     }
 
     let welcome_message = &commit_builder.build()?.welcome_messages[0];
@@ -123,8 +126,8 @@ fn make_groups_worst_case<P: CryptoProvider + Clone>(
     // Bob's clients join the group.
     let mut groups = vec![alice_group];
 
-    for bob_client in &bob_clients {
-        let (bob_group, _info) = bob_client.join_group(None, welcome_message)?;
+    for (bob_client, kpkg) in bob_clients.iter().cartesian_product(kpkgs.into_iter()) {
+        let (bob_group, _info) = bob_client.group_joiner(welcome_message, kpkg)?.join()?;
         groups.push(bob_group);
     }