Quelle client_builder.rs Sprache: unbekannt

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// Copyright by contributors to this project.
// SPDX-License-Identifier: (Apache-2.0 OR MIT)

//! Definitions to build a [`Client`].
//!
//! See [`ClientBuilder`].

use crate::{
 cipher_suite::CipherSuite,
 client::Client,
 client_config::ClientConfig,
 extension::{ExtensionType, MlsExtension},
 group::{
 mls_rules::{DefaultMlsRules, MlsRules},
 proposal::ProposalType,
 },
 identity::CredentialType,
 identity::SigningIdentity,
 protocol_version::ProtocolVersion,
 psk::{ExternalPskId, PreSharedKey},
 storage_provider::in_memory::{
 InMemoryGroupStateStorage, InMemoryKeyPackageStorage, InMemoryPreSharedKeyStorage,
 },
 tree_kem::{Capabilities, Lifetime},
 Sealed,
};

#[cfg(feature = "std")]
use crate::time::MlsTime;

use alloc::vec::Vec;

#[cfg(feature = "sqlite")]
use mls_rs_provider_sqlite::{
 SqLiteDataStorageEngine, SqLiteDataStorageError,
 {
 connection_strategy::ConnectionStrategy,
 storage::{SqLiteGroupStateStorage, SqLiteKeyPackageStorage, SqLitePreSharedKeyStorage},
 },
};

#[cfg(feature = "private_message")]
pub use crate::group::padding::PaddingMode;

/// Base client configuration type when instantiating `ClientBuilder`
pub type BaseConfig = Config<
 InMemoryKeyPackageStorage,
 InMemoryPreSharedKeyStorage,
 InMemoryGroupStateStorage,
 Missing,
 DefaultMlsRules,
 Missing,
>;

/// Base client configuration type when instantiating `ClientBuilder`
pub type BaseInMemoryConfig = Config<
 InMemoryKeyPackageStorage,
 InMemoryPreSharedKeyStorage,
 InMemoryGroupStateStorage,
 Missing,
 Missing,
 Missing,
>;

pub type EmptyConfig = Config<Missing, Missing, Missing, Missing, Missing, Missing>;

/// Base client configuration that is backed by SQLite storage.
#[cfg(feature = "sqlite")]
pub type BaseSqlConfig = Config<
 SqLiteKeyPackageStorage,
 SqLitePreSharedKeyStorage,
 SqLiteGroupStateStorage,
 Missing,
 DefaultMlsRules,
 Missing,
>;

/// Builder for [`Client`]
///
/// This is returned by [`Client::builder`] and allows to tweak settings the `Client` will use. At a
/// minimum, the builder must be told the [`CryptoProvider`] and [`IdentityProvider`] to use. Other
/// settings have default values. This means that the following
/// methods must be called before [`ClientBuilder::build`]:
///
/// - To specify the [`CryptoProvider`]: [`ClientBuilder::crypto_provider`]
/// - To specify the [`IdentityProvider`]: [`ClientBuilder::identity_provider`]
///
/// # Example
///
/// ```
/// use mls_rs::{
/// Client,
/// identity::{SigningIdentity, basic::{BasicIdentityProvider, BasicCredential}},
/// CipherSuite,
/// };
///
/// use mls_rs_crypto_openssl::OpensslCryptoProvider;
///
/// // Replace by code to load the certificate and secret key
/// let secret_key = b"never hard-code secrets".to_vec().into();
/// let public_key = b"test invalid public key".to_vec().into();
/// let basic_identity = BasicCredential::new(b"name".to_vec());
/// let signing_identity = SigningIdentity::new(basic_identity.into_credential(), public_key);
///
///
/// let _client = Client::builder()
/// .crypto_provider(OpensslCryptoProvider::default())
/// .identity_provider(BasicIdentityProvider::new())
/// .signing_identity(signing_identity, secret_key, CipherSuite::CURVE25519_AES128)
/// .build();
/// ```
///
/// # Spelling out a `Client` type
///
/// There are two main ways to spell out a `Client` type if needed (e.g. function return type).
///
/// The first option uses `impl MlsConfig`:
/// ```
/// use mls_rs::{
/// Client,
/// client_builder::MlsConfig,
/// identity::{SigningIdentity, basic::{BasicIdentityProvider, BasicCredential}},
/// CipherSuite,
/// };
///
/// use mls_rs_crypto_openssl::OpensslCryptoProvider;
///
/// fn make_client() -> Client<impl MlsConfig> {
/// // Replace by code to load the certificate and secret key
/// let secret_key = b"never hard-code secrets".to_vec().into();
/// let public_key = b"test invalid public key".to_vec().into();
/// let basic_identity = BasicCredential::new(b"name".to_vec());
/// let signing_identity = SigningIdentity::new(basic_identity.into_credential(), public_key);
///
/// Client::builder()
/// .crypto_provider(OpensslCryptoProvider::default())
/// .identity_provider(BasicIdentityProvider::new())
/// .signing_identity(signing_identity, secret_key, CipherSuite::CURVE25519_AES128)
/// .build()
/// }
///```
///
/// The second option is more verbose and consists in writing the full `Client` type:
/// ```
/// use mls_rs::{
/// Client,
/// client_builder::{BaseConfig, WithIdentityProvider, WithCryptoProvider},
/// identity::{SigningIdentity, basic::{BasicIdentityProvider, BasicCredential}},
/// CipherSuite,
/// };
///
/// use mls_rs_crypto_openssl::OpensslCryptoProvider;
///
/// type MlsClient = Client<
/// WithIdentityProvider<
/// BasicIdentityProvider,
/// WithCryptoProvider<OpensslCryptoProvider, BaseConfig>,
/// >,
/// >;
///
/// fn make_client_2() -> MlsClient {
/// // Replace by code to load the certificate and secret key
/// let secret_key = b"never hard-code secrets".to_vec().into();
/// let public_key = b"test invalid public key".to_vec().into();
/// let basic_identity = BasicCredential::new(b"name".to_vec());
/// let signing_identity = SigningIdentity::new(basic_identity.into_credential(), public_key);
///
/// Client::builder()
/// .crypto_provider(OpensslCryptoProvider::default())
/// .identity_provider(BasicIdentityProvider::new())
/// .signing_identity(signing_identity, secret_key, CipherSuite::CURVE25519_AES128)
/// .build()
/// }
///
/// ```
#[derive(Debug)]
pub struct ClientBuilder<C>(C);

impl Default for ClientBuilder<BaseConfig> {
 fn default() -> Self {
 Self::new()
 }
}

impl<C> ClientBuilder<C> {
 pub(crate) fn from_config(c: C) -> Self {
 Self(c)
 }
}

impl ClientBuilder<BaseConfig> {
 /// Create a new client builder with default in-memory providers
 pub fn new() -> Self {
 Self(Config(ConfigInner {
 settings: Default::default(),
 key_package_repo: Default::default(),
 psk_store: Default::default(),
 group_state_storage: Default::default(),
 identity_provider: Missing,
 mls_rules: DefaultMlsRules::new(),
 crypto_provider: Missing,
 signer: Default::default(),
 signing_identity: Default::default(),
 version: ProtocolVersion::MLS_10,
 }))
 }
}

impl ClientBuilder<EmptyConfig> {
 pub fn new_empty() -> Self {
 Self(Config(ConfigInner {
 settings: Default::default(),
 key_package_repo: Missing,
 psk_store: Missing,
 group_state_storage: Missing,
 identity_provider: Missing,
 mls_rules: Missing,
 crypto_provider: Missing,
 signer: Default::default(),
 signing_identity: Default::default(),
 version: ProtocolVersion::MLS_10,
 }))
 }
}

#[cfg(feature = "sqlite")]
impl ClientBuilder<BaseSqlConfig> {
 /// Create a new client builder with SQLite storage providers.
 pub fn new_sqlite<CS: ConnectionStrategy>(
 storage: SqLiteDataStorageEngine<CS>,
 ) -> Result<Self, SqLiteDataStorageError> {
 Ok(Self(Config(ConfigInner {
 settings: Default::default(),
 key_package_repo: storage.key_package_storage()?,
 psk_store: storage.pre_shared_key_storage()?,
 group_state_storage: storage.group_state_storage()?,
 identity_provider: Missing,
 mls_rules: DefaultMlsRules::new(),
 crypto_provider: Missing,
 signer: Default::default(),
 signing_identity: Default::default(),
 version: ProtocolVersion::MLS_10,
 })))
 }
}

impl<C: IntoConfig> ClientBuilder<C> {
 /// Add an extension type to the list of extension types supported by the client.
 pub fn extension_type(self, type_: ExtensionType) -> ClientBuilder<IntoConfigOutput<C>> {
 self.extension_types(Some(type_))
 }

 /// Add multiple extension types to the list of extension types supported by the client.
 pub fn extension_types(self, types: I) -> ClientBuilder<IntoConfigOutput<C>>
 where
 I: IntoIterator<Item = ExtensionType>,
 {
 let mut c = self.0.into_config();
 c.0.settings.extension_types.extend(types);
 ClientBuilder(c)
 }

 /// Add a custom proposal type to the list of proposals types supported by the client.
 pub fn custom_proposal_type(self, type_: ProposalType) -> ClientBuilder<IntoConfigOutput<C>> {
 self.custom_proposal_types(Some(type_))
 }

 /// Add multiple custom proposal types to the list of proposal types supported by the client.
 pub fn custom_proposal_types(self, types: I) -> ClientBuilder<IntoConfigOutput<C>>
 where
 I: IntoIterator<Item = ProposalType>,
 {
 let mut c = self.0.into_config();
 c.0.settings.custom_proposal_types.extend(types);
 ClientBuilder(c)
 }

 /// Add a protocol version to the list of protocol versions supported by the client.
 ///
 /// If no protocol version is explicitly added, the client will support all protocol versions
 /// supported by this crate.
 pub fn protocol_version(self, version: ProtocolVersion) -> ClientBuilder<IntoConfigOutput<C>> {
 self.protocol_versions(Some(version))
 }

 /// Add multiple protocol versions to the list of protocol versions supported by the client.
 ///
 /// If no protocol version is explicitly added, the client will support all protocol versions
 /// supported by this crate.
 pub fn protocol_versions(self, versions: I) -> ClientBuilder<IntoConfigOutput<C>>
 where
 I: IntoIterator<Item = ProtocolVersion>,
 {
 let mut c = self.0.into_config();
 c.0.settings.protocol_versions.extend(versions);
 ClientBuilder(c)
 }

 /// Add a key package extension to the list of key package extensions supported by the client.
 pub fn key_package_extension<T>(
 self,
 extension: T,
 ) -> Result<ClientBuilder<IntoConfigOutput<C>>, ExtensionError>
 where
 T: MlsExtension,
 Self: Sized,
 {
 let mut c = self.0.into_config();
 c.0.settings.key_package_extensions.set_from(extension)?;
 Ok(ClientBuilder(c))
 }

 /// Add multiple key package extensions to the list of key package extensions supported by the
 /// client.
 pub fn key_package_extensions(
 self,
 extensions: ExtensionList,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.settings.key_package_extensions.append(extensions);
 ClientBuilder(c)
 }

 /// Add a leaf node extension to the list of leaf node extensions supported by the client.
 pub fn leaf_node_extension<T>(
 self,
 extension: T,
 ) -> Result<ClientBuilder<IntoConfigOutput<C>>, ExtensionError>
 where
 T: MlsExtension,
 Self: Sized,
 {
 let mut c = self.0.into_config();
 c.0.settings.leaf_node_extensions.set_from(extension)?;
 Ok(ClientBuilder(c))
 }

 /// Add multiple leaf node extensions to the list of leaf node extensions supported by the
 /// client.
 pub fn leaf_node_extensions(
 self,
 extensions: ExtensionList,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.settings.leaf_node_extensions.append(extensions);
 ClientBuilder(c)
 }

 /// Set the lifetime duration in seconds of key packages generated by the client.
 pub fn key_package_lifetime(self, duration_in_s: u64) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.settings.lifetime_in_s = duration_in_s;
 ClientBuilder(c)
 }

 /// Set the key package repository to be used by the client.
 ///
 /// By default, an in-memory repository is used.
 pub fn key_package_repo<K>(self, key_package_repo: K) -> ClientBuilder<WithKeyPackageRepo<K, C>>
 where
 K: KeyPackageStorage,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo,
 psk_store: c.psk_store,
 group_state_storage: c.group_state_storage,
 identity_provider: c.identity_provider,
 mls_rules: c.mls_rules,
 crypto_provider: c.crypto_provider,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the PSK store to be used by the client.
 ///
 /// By default, an in-memory store is used.
 pub fn psk_store(self, psk_store: P) -> ClientBuilder<WithPskStore<P, C>>
 where
 P: PreSharedKeyStorage,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo: c.key_package_repo,
 psk_store,
 group_state_storage: c.group_state_storage,
 identity_provider: c.identity_provider,
 mls_rules: c.mls_rules,
 crypto_provider: c.crypto_provider,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the group state storage to be used by the client.
 ///
 /// By default, an in-memory storage is used.
 pub fn group_state_storage<G>(
 self,
 group_state_storage: G,
 ) -> ClientBuilder<WithGroupStateStorage<G, C>>
 where
 G: GroupStateStorage,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo: c.key_package_repo,
 psk_store: c.psk_store,
 group_state_storage,
 identity_provider: c.identity_provider,
 crypto_provider: c.crypto_provider,
 mls_rules: c.mls_rules,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the identity validator to be used by the client.
 pub fn identity_provider(
 self,
 identity_provider: I,
 ) -> ClientBuilder<WithIdentityProvider<I, C>>
 where
 I: IdentityProvider,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo: c.key_package_repo,
 psk_store: c.psk_store,
 group_state_storage: c.group_state_storage,
 identity_provider,
 mls_rules: c.mls_rules,
 crypto_provider: c.crypto_provider,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the crypto provider to be used by the client.
 pub fn crypto_provider<Cp>(
 self,
 crypto_provider: Cp,
 ) -> ClientBuilder<WithCryptoProvider<Cp, C>>
 where
 Cp: CryptoProvider,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo: c.key_package_repo,
 psk_store: c.psk_store,
 group_state_storage: c.group_state_storage,
 identity_provider: c.identity_provider,
 mls_rules: c.mls_rules,
 crypto_provider,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the user-defined proposal rules to be used by the client.
 ///
 /// User-defined rules are used when sending and receiving commits before
 /// enforcing general MLS protocol rules. If the rule set returns an error when
 /// receiving a commit, the entire commit is considered invalid. If the
 /// rule set would return an error when sending a commit, individual proposals
 /// may be filtered out to compensate.
 pub fn mls_rules<Pr>(self, mls_rules: Pr) -> ClientBuilder<WithMlsRules<Pr, C>>
 where
 Pr: MlsRules,
 {
 let Config(c) = self.0.into_config();

 ClientBuilder(Config(ConfigInner {
 settings: c.settings,
 key_package_repo: c.key_package_repo,
 psk_store: c.psk_store,
 group_state_storage: c.group_state_storage,
 identity_provider: c.identity_provider,
 mls_rules,
 crypto_provider: c.crypto_provider,
 signer: c.signer,
 signing_identity: c.signing_identity,
 version: c.version,
 }))
 }

 /// Set the protocol version used by the client. By default, the client uses version MLS 1.0
 pub fn used_protocol_version(
 self,
 version: ProtocolVersion,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.version = version;
 ClientBuilder(c)
 }

 /// Set the signing identity used by the client as well as the matching signer and cipher suite.
 /// This must be called in order to create groups and key packages.
 pub fn signing_identity(
 self,
 signing_identity: SigningIdentity,
 signer: SignatureSecretKey,
 cipher_suite: CipherSuite,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.signer = Some(signer);
 c.0.signing_identity = Some((signing_identity, cipher_suite));
 ClientBuilder(c)
 }

 /// Set the signer used by the client. This must be called in order to join groups.
 pub fn signer(self, signer: SignatureSecretKey) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.signer = Some(signer);
 ClientBuilder(c)
 }

 #[cfg(any(test, feature = "test_util"))]
 pub(crate) fn key_package_not_before(
 self,
 key_package_not_before: u64,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.settings.key_package_not_before = Some(key_package_not_before);
 ClientBuilder(c)
 }
}

impl<C: IntoConfig> ClientBuilder<C>
where
 C::KeyPackageRepository: KeyPackageStorage + Clone,
 C::PskStore: PreSharedKeyStorage + Clone,
 C::GroupStateStorage: GroupStateStorage + Clone,
 C::IdentityProvider: IdentityProvider + Clone,
 C::MlsRules: MlsRules + Clone,
 C::CryptoProvider: CryptoProvider + Clone,
{
 pub(crate) fn build_config(self) -> IntoConfigOutput<C> {
 let mut c = self.0.into_config();

 if c.0.settings.protocol_versions.is_empty() {
 c.0.settings.protocol_versions = ProtocolVersion::all().collect();
 }

 c
 }

 /// Build a client.
 ///
 /// See [`ClientBuilder`] documentation if the return type of this function needs to be spelled
 /// out.
 pub fn build(self) -> Client<IntoConfigOutput<C>> {
 let mut c = self.build_config();
 let version = c.0.version;
 let signer = c.0.signer.take();
 let signing_identity = c.0.signing_identity.take();

 Client::new(c, signer, signing_identity, version)
 }
}

impl<C: IntoConfig<PskStore = InMemoryPreSharedKeyStorage>> ClientBuilder<C> {
 /// Add a PSK to the in-memory PSK store.
 pub fn psk(
 self,
 psk_id: ExternalPskId,
 psk: PreSharedKey,
 ) -> ClientBuilder<IntoConfigOutput<C>> {
 let mut c = self.0.into_config();
 c.0.psk_store.insert(psk_id, psk);
 ClientBuilder(c)
 }
}

/// Marker type for required `ClientBuilder` services that have not been specified yet.
#[derive(Debug)]
pub struct Missing;

/// Change the key package repository used by a client configuration.
///
/// See [`ClientBuilder::key_package_repo`].
pub type WithKeyPackageRepo<K, C> = Config<
 K,
 <C as IntoConfig>::PskStore,
 <C as IntoConfig>::GroupStateStorage,
 <C as IntoConfig>::IdentityProvider,
 <C as IntoConfig>::MlsRules,
 <C as IntoConfig>::CryptoProvider,
>;

/// Change the PSK store used by a client configuration.
///
/// See [`ClientBuilder::psk_store`].
pub type WithPskStore<P, C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 P,
 <C as IntoConfig>::GroupStateStorage,
 <C as IntoConfig>::IdentityProvider,
 <C as IntoConfig>::MlsRules,
 <C as IntoConfig>::CryptoProvider,
>;

/// Change the group state storage used by a client configuration.
///
/// See [`ClientBuilder::group_state_storage`].
pub type WithGroupStateStorage<G, C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 <C as IntoConfig>::PskStore,
 G,
 <C as IntoConfig>::IdentityProvider,
 <C as IntoConfig>::MlsRules,
 <C as IntoConfig>::CryptoProvider,
>;

/// Change the identity validator used by a client configuration.
///
/// See [`ClientBuilder::identity_provider`].
pub type WithIdentityProvider<I, C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 <C as IntoConfig>::PskStore,
 <C as IntoConfig>::GroupStateStorage,
 I,
 <C as IntoConfig>::MlsRules,
 <C as IntoConfig>::CryptoProvider,
>;

/// Change the proposal rules used by a client configuration.
///
/// See [`ClientBuilder::mls_rules`].
pub type WithMlsRules<Pr, C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 <C as IntoConfig>::PskStore,
 <C as IntoConfig>::GroupStateStorage,
 <C as IntoConfig>::IdentityProvider,
 Pr,
 <C as IntoConfig>::CryptoProvider,
>;

/// Change the crypto provider used by a client configuration.
///
/// See [`ClientBuilder::crypto_provider`].
pub type WithCryptoProvider<Cp, C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 <C as IntoConfig>::PskStore,
 <C as IntoConfig>::GroupStateStorage,
 <C as IntoConfig>::IdentityProvider,
 <C as IntoConfig>::MlsRules,
 Cp,
>;

/// Helper alias for `Config`.
pub type IntoConfigOutput<C> = Config<
 <C as IntoConfig>::KeyPackageRepository,
 <C as IntoConfig>::PskStore,
 <C as IntoConfig>::GroupStateStorage,
 <C as IntoConfig>::IdentityProvider,
 <C as IntoConfig>::MlsRules,
 <C as IntoConfig>::CryptoProvider,
>;

/// Helper alias to make a `Config` from a `ClientConfig`
pub type MakeConfig<C> = Config<
 <C as ClientConfig>::KeyPackageRepository,
 <C as ClientConfig>::PskStore,
 <C as ClientConfig>::GroupStateStorage,
 <C as ClientConfig>::IdentityProvider,
 <C as ClientConfig>::MlsRules,
 <C as ClientConfig>::CryptoProvider,
>;

impl<Kpr, Ps, Gss, Ip, Pr, Cp> ClientConfig for ConfigInner<Kpr, Ps, Gss, Ip, Pr, Cp>
where
 Kpr: KeyPackageStorage + Clone,
 Ps: PreSharedKeyStorage + Clone,
 Gss: GroupStateStorage + Clone,
 Ip: IdentityProvider + Clone,
 Pr: MlsRules + Clone,
 Cp: CryptoProvider + Clone,
{
 type KeyPackageRepository = Kpr;
 type PskStore = Ps;
 type GroupStateStorage = Gss;
 type IdentityProvider = Ip;
 type MlsRules = Pr;
 type CryptoProvider = Cp;

 fn supported_extensions(&self) -> Vec<ExtensionType> {
 self.settings.extension_types.clone()
 }

 fn supported_protocol_versions(&self) -> Vec<ProtocolVersion> {
 self.settings.protocol_versions.clone()
 }

 fn key_package_repo(&self) -> Self::KeyPackageRepository {
 self.key_package_repo.clone()
 }

 fn mls_rules(&self) -> Self::MlsRules {
 self.mls_rules.clone()
 }

 fn secret_store(&self) -> Self::PskStore {
 self.psk_store.clone()
 }

 fn group_state_storage(&self) -> Self::GroupStateStorage {
 self.group_state_storage.clone()
 }

 fn identity_provider(&self) -> Self::IdentityProvider {
 self.identity_provider.clone()
 }

 fn crypto_provider(&self) -> Self::CryptoProvider {
 self.crypto_provider.clone()
 }

 fn key_package_extensions(&self) -> ExtensionList {
 self.settings.key_package_extensions.clone()
 }

 fn leaf_node_extensions(&self) -> ExtensionList {
 self.settings.leaf_node_extensions.clone()
 }

 fn lifetime(&self) -> Lifetime {
 #[cfg(feature = "std")]
 let now_timestamp = MlsTime::now().seconds_since_epoch();

 #[cfg(not(feature = "std"))]
 let now_timestamp = 0;

 #[cfg(test)]
 let now_timestamp = self
 .settings
 .key_package_not_before
 .unwrap_or(now_timestamp);

 Lifetime {
 not_before: now_timestamp,
 not_after: now_timestamp + self.settings.lifetime_in_s,
 }
 }

 fn supported_custom_proposals(&self) -> Vec<crate::group::proposal::ProposalType> {
 self.settings.custom_proposal_types.clone()
 }
}

impl<Kpr, Ps, Gss, Ip, Pr, Cp> Sealed for Config<Kpr, Ps, Gss, Ip, Pr, Cp> {}

impl<Kpr, Ps, Gss, Ip, Pr, Cp> MlsConfig for Config<Kpr, Ps, Gss, Ip, Pr, Cp>
where
 Kpr: KeyPackageStorage + Clone,

 Ps: PreSharedKeyStorage + Clone,
 Gss: GroupStateStorage + Clone,
 Ip: IdentityProvider + Clone,
 Pr: MlsRules + Clone,
 Cp: CryptoProvider + Clone,
{
 type Output = ConfigInner<Kpr, Ps, Gss, Ip, Pr, Cp>;

 fn get(&self) -> &Self::Output {
 &self.0
 }
}

/// Helper trait to allow consuming crates to easily write a client type as `Client<impl MlsConfig>`
///
/// It is not meant to be implemented by consuming crates. `T: MlsConfig` implies `T: ClientConfig`.
pub trait MlsConfig: Clone + Send + Sync + Sealed {
 #[doc(hidden)]
 type Output: ClientConfig;

 #[doc(hidden)]
 fn get(&self) -> &Self::Output;
}

/// Blanket implementation so that `T: MlsConfig` implies `T: ClientConfig`
impl<T: MlsConfig> ClientConfig for T {
 type KeyPackageRepository = <T::Output as ClientConfig>::KeyPackageRepository;
 type PskStore = <T::Output as ClientConfig>::PskStore;
 type GroupStateStorage = <T::Output as ClientConfig>::GroupStateStorage;
 type IdentityProvider = <T::Output as ClientConfig>::IdentityProvider;
 type MlsRules = <T::Output as ClientConfig>::MlsRules;
 type CryptoProvider = <T::Output as ClientConfig>::CryptoProvider;

 fn supported_extensions(&self) -> Vec<ExtensionType> {
 self.get().supported_extensions()
 }

 fn supported_custom_proposals(&self) -> Vec<ProposalType> {
 self.get().supported_custom_proposals()
 }

 fn supported_protocol_versions(&self) -> Vec<ProtocolVersion> {
 self.get().supported_protocol_versions()
 }

 fn key_package_repo(&self) -> Self::KeyPackageRepository {
 self.get().key_package_repo()
 }

 fn mls_rules(&self) -> Self::MlsRules {
 self.get().mls_rules()
 }

 fn secret_store(&self) -> Self::PskStore {
 self.get().secret_store()
 }

 fn group_state_storage(&self) -> Self::GroupStateStorage {
 self.get().group_state_storage()
 }

 fn identity_provider(&self) -> Self::IdentityProvider {
 self.get().identity_provider()
 }

 fn crypto_provider(&self) -> Self::CryptoProvider {
 self.get().crypto_provider()
 }

 fn key_package_extensions(&self) -> ExtensionList {
 self.get().key_package_extensions()
 }

 fn leaf_node_extensions(&self) -> ExtensionList {
 self.get().leaf_node_extensions()
 }

 fn lifetime(&self) -> Lifetime {
 self.get().lifetime()
 }

 fn capabilities(&self) -> Capabilities {
 self.get().capabilities()
 }

 fn version_supported(&self, version: ProtocolVersion) -> bool {
 self.get().version_supported(version)
 }

 fn supported_credential_types(&self) -> Vec<CredentialType> {
 self.get().supported_credential_types()
 }
}

#[derive(Clone, Debug)]
pub(crate) struct Settings {
 pub(crate) extension_types: Vec<ExtensionType>,
 pub(crate) protocol_versions: Vec<ProtocolVersion>,
 pub(crate) custom_proposal_types: Vec<ProposalType>,
 pub(crate) key_package_extensions: ExtensionList,
 pub(crate) leaf_node_extensions: ExtensionList,
 pub(crate) lifetime_in_s: u64,
 #[cfg(any(test, feature = "test_util"))]
 pub(crate) key_package_not_before: Option<u64>,
}

impl Default for Settings {
 fn default() -> Self {
 Self {
 extension_types: Default::default(),
 protocol_versions: Default::default(),
 key_package_extensions: Default::default(),
 leaf_node_extensions: Default::default(),
 lifetime_in_s: 365 * 24 * 3600,
 custom_proposal_types: Default::default(),
 #[cfg(any(test, feature = "test_util"))]
 key_package_not_before: None,
 }
 }
}

pub(crate) fn recreate_config<T: ClientConfig>(
 c: T,
 signer: Option<SignatureSecretKey>,
 signing_identity: Option<(SigningIdentity, CipherSuite)>,
 version: ProtocolVersion,
) -> MakeConfig<T> {
 Config(ConfigInner {
 settings: Settings {
 extension_types: c.supported_extensions(),
 protocol_versions: c.supported_protocol_versions(),
 custom_proposal_types: c.supported_custom_proposals(),
 key_package_extensions: c.key_package_extensions(),
 leaf_node_extensions: c.leaf_node_extensions(),
 lifetime_in_s: {
 let l = c.lifetime();
 l.not_after - l.not_before
 },
 #[cfg(any(test, feature = "test_util"))]
 key_package_not_before: None,
 },
 key_package_repo: c.key_package_repo(),
 psk_store: c.secret_store(),
 group_state_storage: c.group_state_storage(),
 identity_provider: c.identity_provider(),
 mls_rules: c.mls_rules(),
 crypto_provider: c.crypto_provider(),
 signer,
 signing_identity,
 version,
 })
}

/// Definitions meant to be private that are inaccessible outside this crate. They need to be marked
/// `pub` because they appear in public definitions.
mod private {
 use mls_rs_core::{
 crypto::{CipherSuite, SignatureSecretKey},
 identity::SigningIdentity,
 protocol_version::ProtocolVersion,
 };

 use crate::client_builder::{IntoConfigOutput, Settings};

 #[derive(Clone, Debug)]
 pub struct Config<Kpr, Ps, Gss, Ip, Pr, Cp>(pub(crate) ConfigInner<Kpr, Ps, Gss, Ip, Pr, Cp>);

 #[derive(Clone, Debug)]
 pub struct ConfigInner<Kpr, Ps, Gss, Ip, Pr, Cp> {
 pub(crate) settings: Settings,
 pub(crate) key_package_repo: Kpr,
 pub(crate) psk_store: Ps,
 pub(crate) group_state_storage: Gss,
 pub(crate) identity_provider: Ip,
 pub(crate) mls_rules: Pr,
 pub(crate) crypto_provider: Cp,
 pub(crate) signer: Option<SignatureSecretKey>,
 pub(crate) signing_identity: Option<(SigningIdentity, CipherSuite)>,
 pub(crate) version: ProtocolVersion,
 }

 pub trait IntoConfig {
 type KeyPackageRepository;
 type PskStore;
 type GroupStateStorage;
 type IdentityProvider;
 type MlsRules;
 type CryptoProvider;

 fn into_config(self) -> IntoConfigOutput<Self>;
 }

 impl<Kpr, Ps, Gss, Ip, Pr, Cp> IntoConfig for Config<Kpr, Ps, Gss, Ip, Pr, Cp> {
 type KeyPackageRepository = Kpr;
 type PskStore = Ps;
 type GroupStateStorage = Gss;
 type IdentityProvider = Ip;
 type MlsRules = Pr;
 type CryptoProvider = Cp;

 fn into_config(self) -> Self {
 self
 }
 }
}

use mls_rs_core::{
 crypto::{CryptoProvider, SignatureSecretKey},
 extension::{ExtensionError, ExtensionList},
 group::GroupStateStorage,
 identity::IdentityProvider,
 key_package::KeyPackageStorage,
 psk::PreSharedKeyStorage,
};
use private::{Config, ConfigInner, IntoConfig};

#[cfg(test)]
pub(crate) mod test_utils {
 use crate::{
 client_builder::{BaseConfig, ClientBuilder, WithIdentityProvider},
 crypto::test_utils::TestCryptoProvider,
 identity::{
 basic::BasicIdentityProvider,
 test_utils::{get_test_signing_identity, BasicWithCustomProvider},
 },
 CipherSuite,
 };

 use super::WithCryptoProvider;

 pub type TestClientConfig = WithIdentityProvider<
 BasicWithCustomProvider,
 WithCryptoProvider<TestCryptoProvider, BaseConfig>,
 >;

 pub type TestClientBuilder = ClientBuilder<TestClientConfig>;

 impl TestClientBuilder {
 pub fn new_for_test() -> Self {
 ClientBuilder::new()
 .crypto_provider(TestCryptoProvider::new())
 .identity_provider(BasicWithCustomProvider::new(BasicIdentityProvider::new()))
 }

 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
 pub async fn with_random_signing_identity(
 self,
 identity: &str,
 cipher_suite: CipherSuite,
 ) -> Self {
 let (signing_identity, signer) =
 get_test_signing_identity(cipher_suite, identity.as_bytes()).await;
 self.signing_identity(signing_identity, signer, cipher_suite)
 }
 }
}

Quelle client_builder.rs Sprache: unbekannt

[ Dauer der Verarbeitung: 0.33 Sekunden (vorverarbeitet) ]