Struct ironoxide::IronOxide

pub struct IronOxide { /* fields omitted */ }

Struct that is used to make authenticated requests to the IronCore API. Instantiated with the details of an account's various ids, device, and signing keys. Once instantiated all operations will be performed in the context of the account provided.

Methods

impl IronOxide

pub fn device(&self) -> &DeviceContext

Get the DeviceContext instance that was used to create this SDK instance

pub fn clear_policy_cache(&self) -> usize

Clears all entries from the policy cache.

Returns

Number of entries cleared from the cache

pub async fn rotate_all<'_, '_, '_>(
    &'_ self,
    rotations: &'_ PrivateKeyRotationCheckResult,
    password: &'_ str,
    timeout: Option<Duration>
) -> Result<(Option<UserUpdatePrivateKeyResult>, Option<Vec<GroupUpdatePrivateKeyResult>>)>

Rotate the private key of the calling user and all groups they are an administrator of where needs_rotation is true. Note that this function has the potential to take much longer than other functions, as rotation will be done individually on each user/group. If rotation is only needed for a specific group, it is strongly recommended to call user_rotate_private_key() or group_rotate_private_key() instead.

Arguments

• rotations - PrivateKeyRotationCheckResult that holds all users and groups to be rotated
• password - Password to unlock the current user's user master key
• timeout - timeout for rotate_all. This is a separate timeout from the SDK-wide timeout as it is expected that this operation might take significantly longer than other operations.

Trait Implementations

impl BlindIndexSearchInitialize for IronOxide

fn create_blind_index<'life0, 'life1, 'async_trait>(
    &'life0 self,
    group_id: &'life1 GroupId
) -> Pin<Box<dyn Future<Output = Result<EncryptedBlindIndexSalt>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Create an index and encrypt it to the provided group_id.

impl Debug for IronOxide

Manual implementation of Debug without the recrypt or rng fields

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl DocumentAdvancedOps for IronOxide

fn document_encrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    data: &'life1 [u8],
    encrypt_opts: &'life2 DocumentEncryptOpts
) -> Pin<Box<dyn Future<Output = Result<DocumentEncryptUnmanagedResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

(Advanced) Encrypt the provided document bytes. Return the encrypted document encryption keys (EDEKs) instead of creating a document entry in the IronCore webservice.

fn document_decrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    encrypted_data: &'life1 [u8],
    encrypted_deks: &'life2 [u8]
) -> Pin<Box<dyn Future<Output = Result<DocumentDecryptUnmanagedResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

(Advanced) Decrypt a document not managed by the ironcore service. Both the encrypted data and the encrypted deks need to be provided.

impl DocumentOps for IronOxide

fn document_list<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<DocumentListResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

List all of the documents that the current user is able to decrypt.

fn document_get_metadata<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 DocumentId
) -> Pin<Box<dyn Future<Output = Result<DocumentMetadataResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the metadata for a specific document given its ID.

fn document_get_id_from_bytes(
    &self,
    encrypted_document: &[u8]
) -> Result<DocumentId>

Attempt to parse the document ID out of an encrypted document.

fn document_encrypt<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    document_data: &'life1 [u8],
    encrypt_opts: &'life2 DocumentEncryptOpts
) -> Pin<Box<dyn Future<Output = Result<DocumentEncryptResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Encrypt the provided document bytes.

fn document_update_bytes<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 DocumentId,
    new_document_data: &'life2 [u8]
) -> Pin<Box<dyn Future<Output = Result<DocumentEncryptResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Update the encrypted content of an existing document. Persists any existing access to other users and groups.

fn document_decrypt<'life0, 'life1, 'async_trait>(
    &'life0 self,
    encrypted_document: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<DocumentDecryptResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Decrypts the provided encrypted document and returns details about the document as well as its decrypted bytes.

fn document_update_name<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 DocumentId,
    name: Option<&'life2 DocumentName>
) -> Pin<Box<dyn Future<Output = Result<DocumentMetadataResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Update a document name to a new value or clear its value.

fn document_grant_access<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 DocumentId,
    grant_list: &'life2 Vec<UserOrGroup>
) -> Pin<Box<dyn Future<Output = Result<DocumentAccessResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Grant access to a document. Recipients of document access can be either users or groups.

fn document_revoke_access<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 DocumentId,
    revoke_list: &'life2 Vec<UserOrGroup>
) -> Pin<Box<dyn Future<Output = Result<DocumentAccessResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Revoke access from a document. Revocation of document access can be either users or groups.

impl GroupOps for IronOxide

fn group_list<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GroupListResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

List all of the groups that the current user is either an admin or member of.

fn group_create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    opts: &'life1 GroupCreateOpts
) -> Pin<Box<dyn Future<Output = Result<GroupCreateResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Create a group. The creating user will become a group admin and by default a group member.

fn group_get_metadata<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId
) -> Pin<Box<dyn Future<Output = Result<GroupGetResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the full metadata for a specific group given its ID.

fn group_delete<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId
) -> Pin<Box<dyn Future<Output = Result<GroupId>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Delete the identified group. Group does not have to be empty of admins/members in order to delete the group. Warning: Deletion of a group will cause all documents encrypted to that group to no longer be decryptable. Caution should be used when deleting groups.

fn group_update_name<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId,
    name: Option<&'life2 GroupName>
) -> Pin<Box<dyn Future<Output = Result<GroupMetaResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Update a group name to a new value or clear its value.

fn group_add_members<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId,
    grant_list: &'life2 [UserId]
) -> Pin<Box<dyn Future<Output = Result<GroupAccessEditResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Add the users as members of a group.

fn group_remove_members<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId,
    revoke_list: &'life2 [UserId]
) -> Pin<Box<dyn Future<Output = Result<GroupAccessEditResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Remove a list of users as members from the group.

fn group_add_admins<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId,
    users: &'life2 [UserId]
) -> Pin<Box<dyn Future<Output = Result<GroupAccessEditResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Add the users as admins of a group.

fn group_remove_admins<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId,
    revoke_list: &'life2 [UserId]
) -> Pin<Box<dyn Future<Output = Result<GroupAccessEditResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Remove a list of users as admins from the group.

fn group_rotate_private_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 GroupId
) -> Pin<Box<dyn Future<Output = Result<GroupUpdatePrivateKeyResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Rotate the provided group's private key, but leave the public key the same. There's no black magic here! This is accomplished via multi-party computation with the IronCore webservice. Note: You must be an admin of the group in order to rotate its private key.

impl UserOps for IronOxide

fn user_create<'life0, 'life1, 'life2, 'async_trait>(
    jwt: &'life0 str,
    password: &'life1 str,
    user_create_opts: &'life2 UserCreateOpts,
    timeout: Option<Duration>
) -> Pin<Box<dyn Future<Output = Result<UserCreateResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait, 

Sync a new user within the IronCore system.

fn user_list_devices<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<UserDeviceListResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all the devices for the current user

fn generate_new_device<'life0, 'life1, 'life2, 'async_trait>(
    jwt: &'life0 str,
    password: &'life1 str,
    device_create_options: &'life2 DeviceCreateOpts,
    timeout: Option<Duration>
) -> Pin<Box<dyn Future<Output = Result<DeviceAddResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait, 

Generates a new device for the user specified in the signed JWT.

fn user_delete_device<'life0, 'life1, 'async_trait>(
    &'life0 self,
    device_id: Option<&'life1 DeviceId>
) -> Pin<Box<dyn Future<Output = Result<DeviceId>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Delete a user device.

fn user_verify<'life0, 'async_trait>(
    jwt: &'life0 str,
    timeout: Option<Duration>
) -> Pin<Box<dyn Future<Output = Result<Option<UserResult>>> + Send + 'async_trait>> where
    'life0: 'async_trait, 

Verify a user given a JWT for their user record.

fn user_get_public_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    users: &'life1 [UserId]
) -> Pin<Box<dyn Future<Output = Result<HashMap<UserId, PublicKey>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get a list of user public keys given their IDs. Allows discovery of which user IDs have keys in the IronCore system to determine of they can be added to groups or have documents shared with them.

fn user_rotate_private_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    password: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<UserUpdatePrivateKeyResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Rotate the current user's private key, but leave the public key the same. There's no black magic here! This is accomplished via multi-party computation with the IronCore webservice.