bitwarden-core 3.0.0

Internal crate for the bitwarden crate. Do not use.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Integration tests for the registration process

use bitwarden_core::key_management::LocalUserDataKeyState;
use bitwarden_test::MemoryRepository;

/// Integration test for registering a new user and unlocking the vault
#[cfg(feature = "internal")]
#[tokio::test]
async fn test_register_initialize_crypto() {
    use std::num::NonZeroU32;

    use bitwarden_core::{
        Client, UserId,
        key_management::{
            EphemeralPinEnvelopeState, MasterPasswordUnlockData, UserKeyState,
            account_cryptographic_state::WrappedAccountCryptographicState,
            crypto::{InitUserCryptoMethod, InitUserCryptoRequest},
        },
    };
    use bitwarden_crypto::Kdf;

    let client = Client::new(None);

    let user_key_repository = MemoryRepository::<UserKeyState>::default();
    client
        .platform()
        .state()
        .register_client_managed(std::sync::Arc::new(user_key_repository));

    client
        .platform()
        .state()
        .register_client_managed(std::sync::Arc::new(
            MemoryRepository::<LocalUserDataKeyState>::default(),
        ));

    client
        .platform()
        .state()
        .register_client_managed(std::sync::Arc::new(MemoryRepository::<
            EphemeralPinEnvelopeState,
        >::default()));

    let email = "test@bitwarden.com";
    let password = "test123";
    let kdf = Kdf::PBKDF2 {
        iterations: NonZeroU32::new(600_000).unwrap(),
    };

    let register_response = client
        .auth()
        .make_register_keys(email.to_owned(), password.to_owned(), kdf.clone())
        .unwrap();

    // Ensure we can initialize the crypto with the new keys
    client
        .crypto()
        .initialize_user_crypto(InitUserCryptoRequest {
            user_id: Some(UserId::new_v4()),
            kdf_params: kdf.clone(),
            email: email.to_owned(),
            account_cryptographic_state: WrappedAccountCryptographicState::V1 {
                private_key: register_response.keys.private,
            },
            method: InitUserCryptoMethod::MasterPasswordUnlock {
                password: password.to_owned(),
                master_password_unlock: MasterPasswordUnlockData {
                    kdf,
                    master_key_wrapped_user_key: register_response.encrypted_user_key,
                    salt: email.to_owned(),
                },
            },
            upgrade_token: None,
        })
        .await
        .unwrap();
}