Struct win_crypto_ng::asymmetric::AsymmetricKey

source ·

pub struct AsymmetricKey<A: Algorithm = AsymmetricAlgorithmId, P: Parts = Public>(_, _, _);

Expand description

Asymmetric key handle.

Can be specified as that of which type is known at run-time (erased) or with a concrete algorithm parameter.

Type-safety

At the time of writing, all of the relevant crypto operations are implemented for only keys whose algorithm is statically known. This means that the keys using the dynamic AsymmetricAlgorithmId need to be re-imported in order to statically verify the algorithm used.

use win_crypto_ng::asymmetric::{AsymmetricAlgorithm, AsymmetricAlgorithmId, AsymmetricKey};
use win_crypto_ng::asymmetric::{Rsa, Private, Import, Export};

let dynamic: AsymmetricKey<AsymmetricAlgorithmId, Private> =
    AsymmetricKey::builder(AsymmetricAlgorithmId::Rsa).key_bits(512).build().unwrap();
let dynamic_blob = dynamic.export().unwrap();

let provider = AsymmetricAlgorithm::open(AsymmetricAlgorithmId::Rsa).unwrap();
let rsa_blob = dynamic_blob.try_into().unwrap_or_else(|_| panic!());
let rsa_key = AsymmetricKey::<Rsa, Private>::import(Rsa, &provider, &rsa_blob).unwrap();
// Can now additional impls for `AsymmetricKey<Rsa, Private>`, e.g.
// rsa_key.decrypt(..);

Generation

use win_crypto_ng::asymmetric::{AsymmetricAlgorithm, AsymmetricAlgorithmId, AsymmetricKey};
use win_crypto_ng::asymmetric::{Rsa, Private};

// Handle to an asymmetric key whose algorithm ID is known at run-time
let handle: AsymmetricKey<AsymmetricAlgorithmId, Private> =
    AsymmetricKey::builder(AsymmetricAlgorithmId::Rsa).key_bits(512).build().unwrap();

// Handle to an asymmetric key whose algorithm is known to be RSA
let handle: AsymmetricKey<Rsa, Private> =
    AsymmetricKey::builder(Rsa).key_bits(512).build().unwrap();

Struct win_crypto_ng::asymmetric::AsymmetricKey

Implementations§

impl AsymmetricKey

pub fn builder<B: Algorithm>(algorithm: B) -> Builder<B>

impl<A: Algorithm, P: Parts> AsymmetricKey<A, P>

pub fn id(&self) -> AsymmetricAlgorithmId

impl<A: Algorithm> AsymmetricKey<A, Private>

pub fn as_public(&self) -> &AsymmetricKey<A, Public>

impl AsymmetricKey<Rsa, Private>

pub fn export_full(&self) -> Result<Box<Blob<RsaKeyFullPrivateBlob>>>

impl AsymmetricKey<Rsa, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &RsaKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Rsa, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &RsaKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP256>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP256>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP384>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP384>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP521>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdsa<NistP521>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<Curve25519>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, private: &[u8] ) -> Result<Self>

impl AsymmetricKey<Ecdh<Curve25519>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, public: &[u8] ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP256>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP256>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP384>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP384>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP521>, Private>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPrivatePayload<'_> ) -> Result<Self>

impl AsymmetricKey<Ecdh<NistP521>, Public>

pub fn import_from_parts( provider: &AsymmetricAlgorithm, parts: &EccKeyPublicPayload<'_> ) -> Result<Self>

impl<P: Parts> AsymmetricKey<Rsa, P>

pub fn encrypt( &self, padding: Option<EncryptionPadding>, data: &[u8] ) -> Result<Box<[u8]>>

impl AsymmetricKey<Rsa, Private>

pub fn decrypt( &self, padding: Option<EncryptionPadding>, data: &[u8] ) -> Result<Box<[u8]>>

Trait Implementations§

impl<'a> Export<AsymmetricAlgorithmId, Private> for AsymmetricKey<AsymmetricAlgorithmId, Private>

type Blob = ErasedKeyBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<AsymmetricAlgorithmId, Public> for AsymmetricKey<AsymmetricAlgorithmId, Public>

type Blob = ErasedKeyBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Dh, Private> for AsymmetricKey<Dh, Private>

type Blob = DhKeyPrivateBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Dh, Public> for AsymmetricKey<Dh, Public>

type Blob = DhKeyPublicBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Dsa, Private> for AsymmetricKey<Dsa, Private>

type Blob = DsaKeyPrivateBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Dsa, Public> for AsymmetricKey<Dsa, Public>

type Blob = DsaKeyPublicBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Ecdh<Curve25519>, Private> for AsymmetricKey<Ecdh<Curve25519>, Private>

type Blob = EccKeyPrivateBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Ecdh<Curve25519>, Public> for AsymmetricKey<Ecdh<Curve25519>, Public>

type Blob = EccKeyPublicBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Ecdh<NistP256>, Private> for AsymmetricKey<Ecdh<NistP256>, Private>

type Blob = EccKeyPrivateBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Ecdh<NistP256>, Public> for AsymmetricKey<Ecdh<NistP256>, Public>

type Blob = EccKeyPublicBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>

impl<'a> Export<Ecdh<NistP384>, Private> for AsymmetricKey<Ecdh<NistP384>, Private>

type Blob = EccKeyPrivateBlob

fn export(&self) -> Result<Box<Blob<Self::Blob>>>