Struct CryptService 

pub struct CryptService { /* private fields */ }

Implementations

impl CryptService

pub fn new( raw_metadata_key: &[u8], raw_data_key: &[u8], inline_crypto_proxy: Option<DeviceSynchronousProxy>, ) -> Self

Creates a new crypt service that supports Starnix user volumes.

pub fn contains_key(&self, key: EncryptionKeyId) -> bool

Returns true if key is registered with the service.

pub fn get_users_for_key(&self, key: EncryptionKeyId) -> Option<Vec<u32>>

Returns the users registered for key.

pub fn add_wrapping_key( &self, raw_key: &[u8], uid: u32, ) -> Result<EncryptionKeyId, Errno>

Adds the specified wrapping key for user uid.

pub async fn handle_connection( &self, stream: CryptRequestStream, ) -> Result<(), Error>

Serves crypt requests.

pub fn forget_wrapping_key( &self, wrapping_key_id: EncryptionKeyId, uid: u32, ) -> Result<(), Errno>

Removes wrapping_key_id for user uid.

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

Trait Implementations

impl Crypt for CryptService

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, flags: FscryptPolicyFlags, ) -> 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. flags specifies the fscrypt policy flags for the object.

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 [(u64, EncryptionKey)], 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: