Struct CryptBase 

pub struct CryptBase { /* private fields */ }

CryptBase is a helper for managing wrapping keys and performing cryptographic operations.

Implementations

impl CryptBase

pub fn new() -> Self

pub fn add_wrapping_key( &self, id: WrappingKeyId, key: [u8; 32], ) -> Result<(), Status>

pub fn set_active_key( &self, purpose: KeyPurpose, id: WrappingKeyId, ) -> Result<(), Status>

pub fn forget_wrapping_key(&self, id: &WrappingKeyId) -> Result<(), Status>

pub fn shutdown(&self)

pub fn set_filesystem_uuid(&mut self, uuid: &[u8; 16])

Fscrypt in INO_LBLK32 and INO_LBLK64 modes mix the filesystem_uuid into key derivation functions. Crypt should be told the uuid ahead of time to support decryption of migrated data. (Note that we make an assumption that there is only one filesystem.)

pub fn use_fxfs_keys_for_fscrypt_dirs(&mut self)

pub fn using_fxfs_keys_for_fscrypt_dirs(&self) -> bool

Trait Implementations

impl Crypt for CryptBase

fn create_key<'life0, 'async_trait>( &'life0 self, owner: u64, purpose: KeyPurpose, ) -> Pin<Box<dyn Future<Output = Result<(FxfsKey, UnwrappedKey), Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

owner is intended to be used such that when the key is wrapped, it appears to be different to that of the same key wrapped by a different owner. In this way, keys can be shared amongst different filesystem objects (e.g. for clones), but it is not possible to tell just by looking at the wrapped keys.

fn create_key_with_id<'life0, 'async_trait>( &'life0 self, owner: u64, wrapping_key_id: WrappingKeyId, object_type: ObjectType, ) -> Pin<Box<dyn Future<Output = Result<(EncryptionKey, UnwrappedKey), Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

owner is intended to be used such that when the key is wrapped, it appears to be different to that of the same key wrapped by a different owner. In this way, keys can be shared amongst different filesystem objects (e.g. for clones), but it is not possible to tell just by looking at the wrapped keys.

fn unwrap_key<'life0, 'life1, 'async_trait>( &'life0 self, wrapped_key: &'life1 WrappedKey, owner: u64, ) -> Pin<Box<dyn Future<Output = Result<UnwrappedKey, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unwraps a single key, returning a raw unwrapped key. This method is generally only used with StreamCipher and FF1. Returns zx::Status::UNAVAILABLE if the key is known but cannot be unwrapped (e.g. it is locked). Returns zx::Status::NOT_FOUND if the wrapping key is not known.

fn unwrap_keys<'life0, 'life1, 'async_trait>( &'life0 self, keys: &'life1 BTreeMap<u64, WrappedKey>, owner: u64, ) -> Pin<Box<dyn Future<Output = Result<CipherSet, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Unwraps object keys and stores the result as a CipherSet mapping key_id to: