Struct SigningKeySetup 

pub struct SigningKeySetup {
    key_type: KeyType,
    key_mechanisms: Vec<KeyMechanism>,
    key_length: Option<u32>,
    signature_type: SignatureType,
    key_context: CryptographicKeyContext,
}

The setup of a cryptographic signing key.

This covers the type of key, its supported mechanisms, its optional length, its signature type and the context in which it is used.

Fields

key_type: KeyType

key_mechanisms: Vec<KeyMechanism>

key_length: Option<u32>

signature_type: SignatureType

key_context: CryptographicKeyContext

Implementations

impl SigningKeySetup

pub fn new( key_type: KeyType, key_mechanisms: Vec<KeyMechanism>, key_length: Option<u32>, signature_type: SignatureType, cryptographic_key_context: CryptographicKeyContext, ) -> Result<Self, Error>

Creates a new SigningKeySetup.

Examples

use signstar_crypto::{
    key::{CryptographicKeyContext, KeyMechanism, KeyType, SignatureType, SigningKeySetup},
    openpgp::OpenPgpUserIdList,
};

SigningKeySetup::new(
    KeyType::Curve25519,
    vec![KeyMechanism::EdDsaSignature],
    None,
    SignatureType::EdDsa,
    CryptographicKeyContext::Raw,
)?;

SigningKeySetup::new(
    KeyType::Curve25519,
    vec![KeyMechanism::EdDsaSignature],
    None,
    SignatureType::EdDsa,
    CryptographicKeyContext::OpenPgp {
        user_ids: OpenPgpUserIdList::new(vec![
            "Foobar McFooface <foobar@mcfooface.org>".parse()?,
        ])?,
        version: "v4".parse()?,
    },
)?;

// this fails because Curve25519 does not support the ECDSA key mechanism
assert!(
    SigningKeySetup::new(
        KeyType::Curve25519,
        vec![KeyMechanism::EcdsaSignature],
        None,
        SignatureType::EdDsa,
        CryptographicKeyContext::OpenPgp {
            user_ids: OpenPgpUserIdList::new(vec![
                "Foobar McFooface <foobar@mcfooface.org>".parse()?
            ])?,
            version: "v4".parse()?,
        },
    )
    .is_err()
);

Errors

Returns an error if

• the key_type and key_mechanisms are incompatible,
• the key_type and key_length are incompatible,
• the key_type, key_mechanisms and signature_type are incompatible,
• or the cryptographic_key_context is not valid.

pub fn key_type(&self) -> KeyType

Returns the KeyType.

pub fn key_mechanisms(&self) -> &[KeyMechanism]

Returns a reference to the list of KeyMechanisms.

pub fn key_length(&self) -> Option<u32>

Returns the optional key length.

pub fn signature_type(&self) -> SignatureType

Returns the SignatureType.

pub fn key_context(&self) -> &CryptographicKeyContext

Returns a reference to the CryptographicKeyContext.

Trait Implementations

impl Clone for SigningKeySetup

fn clone(&self) -> SigningKeySetup

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SigningKeySetup

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SigningKeySetup

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SigningKeySetup

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SigningKeySetup

fn eq(&self, other: &SigningKeySetup) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SigningKeySetup

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SigningKeySetup

impl StructuralPartialEq for SigningKeySetup