Struct KeyManagerProxy

pub struct KeyManagerProxy { /* private fields */ }

Implementations

impl KeyManagerProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.kms/KeyManager.

pub fn take_event_stream(&self) -> KeyManagerEventStream

Get a Stream of events from the remote end of the protocol.

Panics

Panics if the event stream was already taken.

pub fn seal_data( &self, plain_text: Buffer, ) -> QueryResponseFut<KeyManagerSealDataResult, DefaultFuchsiaResourceDialect>

Seal data to an encrypted form.

Seal data to an encrypted form. The sealed data can only be unsealed by the same KMS instance by using UnsealData. plain_text needs to be less than MAX_DATA_SIZE bytes.

pub fn unseal_data( &self, cipher_text: Buffer, ) -> QueryResponseFut<KeyManagerUnsealDataResult, DefaultFuchsiaResourceDialect>

Unseal sealed data.

Unseal data previously sealed by this KMS instance.

pub fn generate_asymmetric_key( &self, key_name: &str, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> QueryResponseFut<KeyManagerGenerateAsymmetricKeyResult, DefaultFuchsiaResourceDialect>

Generate an asymmetric key.

Generate an asymmetric key using key_name as the unique name. key is the generated asymmetric key interface request. If the key_name is not unique, you would get KEY_ALREADY_EXISTS. The generated key can be used to sign data. The algorithm used for generating asymmetric key is ECDSA_SHA512_P521.

pub fn generate_asymmetric_key_with_algorithm( &self, key_name: &str, key_algorithm: AsymmetricKeyAlgorithm, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> QueryResponseFut<KeyManagerGenerateAsymmetricKeyWithAlgorithmResult, DefaultFuchsiaResourceDialect>

Generate an asymmetric key with a specific algorithm.

Generate an asymmetric key using key_name as the unique name and key_algorithm as algorithm. key is the generated asymmetric key interface request. If the key_name is not unique, you would get KEY_ALREADY_EXISTS.

pub fn import_asymmetric_private_key( &self, data: &[u8], key_name: &str, key_algorithm: AsymmetricKeyAlgorithm, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> QueryResponseFut<KeyManagerImportAsymmetricPrivateKeyResult, DefaultFuchsiaResourceDialect>

Import an asymmetric private key with a specific algorithm.

Import an asymmetric private key using key_name as the unique name, key_algorithm as algorithm and data as key data. key is imported asymmetric key interface request. Key data should be in asn.1 encoded DER format. If the key_name is not unique, you would get KEY_ALREADY_EXISTS.

pub fn get_asymmetric_private_key( &self, key_name: &str, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> QueryResponseFut<KeyManagerGetAsymmetricPrivateKeyResult, DefaultFuchsiaResourceDialect>

Get an asymmetric private key handle.

Get an asymmetric private key handle using the key_name. If such key is not found, would return KEY_NOT_FOUND.

pub fn delete_key( &self, key_name: &str, ) -> QueryResponseFut<KeyManagerDeleteKeyResult, DefaultFuchsiaResourceDialect>

Delete a key.

Delete a key for key_name. For all the current handle to the deleted key, they would become invalid and all following requests on those handles would return KEY_NOT_FOUND, user should close the invalid handles once get KEY_NOT_FOUND error.

Trait Implementations

impl Clone for KeyManagerProxy

fn clone(&self) -> KeyManagerProxy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyManagerProxy

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

Formats the value using the given formatter.

impl KeyManagerProxyInterface for KeyManagerProxy

type SealDataResponseFut = QueryResponseFut<Result<Buffer, Error>>

type UnsealDataResponseFut = QueryResponseFut<Result<Buffer, Error>>

type GenerateAsymmetricKeyResponseFut = QueryResponseFut<Result<(), Error>>

type GenerateAsymmetricKeyWithAlgorithmResponseFut = QueryResponseFut<Result<(), Error>>

type ImportAsymmetricPrivateKeyResponseFut = QueryResponseFut<Result<(), Error>>

type GetAsymmetricPrivateKeyResponseFut = QueryResponseFut<Result<(), Error>>

type DeleteKeyResponseFut = QueryResponseFut<Result<(), Error>>

fn seal_data(&self, plain_text: Buffer) -> Self::SealDataResponseFut

fn unseal_data(&self, cipher_text: Buffer) -> Self::UnsealDataResponseFut

fn generate_asymmetric_key( &self, key_name: &str, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> Self::GenerateAsymmetricKeyResponseFut

fn generate_asymmetric_key_with_algorithm( &self, key_name: &str, key_algorithm: AsymmetricKeyAlgorithm, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> Self::GenerateAsymmetricKeyWithAlgorithmResponseFut

fn import_asymmetric_private_key( &self, data: &[u8], key_name: &str, key_algorithm: AsymmetricKeyAlgorithm, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> Self::ImportAsymmetricPrivateKeyResponseFut

fn get_asymmetric_private_key( &self, key_name: &str, key: ServerEnd<AsymmetricPrivateKeyMarker>, ) -> Self::GetAsymmetricPrivateKeyResponseFut

fn delete_key(&self, key_name: &str) -> Self::DeleteKeyResponseFut

impl Proxy for KeyManagerProxy

type Protocol = KeyManagerMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn into_client_end(self) -> Result<ClientEnd<Self::Protocol>, Self>

Attempt to convert the proxy back into a client end.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed(&self) -> OnSignals<'_, Unowned<'_, Handle>>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.