Struct KeyPolicy 

pub struct KeyPolicy {
    pub persistent: bool,
    pub sensitive: bool,
    pub extractable: bool,
    pub wrap_with_trusted_only: bool,
    pub usages: KeyUsages,
}

Security and usage policy for a generated or imported key.

Backends that cannot honour a requested policy MUST return BackendError::OperationNotPermitted rather than silently ignoring it. For example, a PIV backend receiving extractable: true must reject it because PIV keys are always non-extractable by hardware design.

Fields

persistent: bool

Key persists after session ends. Always true for PIV. CKA_TOKEN in PKCS#11.

sensitive: bool

Key material never revealed in plaintext. Always true for PIV. CKA_SENSITIVE.

extractable: bool

Key can be wrapped and exported. Always false for PIV. CKA_EXTRACTABLE.

wrap_with_trusted_only: bool

Key can only be wrapped by a CKA_TRUSTED wrapping key. PKCS#11 CKA_WRAP_WITH_TRUSTED.

usages: KeyUsages

What operations this key is permitted to perform.

Implementations

impl KeyPolicy

pub fn require( &self, usage: KeyUsages, operation: &str, ) -> Result<(), BackendError>

Refuse an operation this policy does not allow.

The policy is what the ceremony asked for at generation. A token enforces it itself; a software backend has no token, so it calls this.

Errors

Returns BackendError::OperationNotPermitted when usage is absent from the policy, naming what the key may do instead.

impl KeyPolicy

pub fn default_for(algorithm: KeyAlgorithm) -> Self

What a key of this algorithm may do when the ceremony says nothing.

A generation step should call this rather than Default, which is the signing default and gives a symmetric key two usages it can never have. Rite holds a symmetric key as a key-encryption key and nothing else, so wrap and unwrap is the whole of what one is for here.

use rite_sdk::{KeyAlgorithm, KeyPolicy, KeyUsages};

let signing = KeyPolicy::default_for(KeyAlgorithm::EcdsaP256);
assert_eq!(signing.usages, KeyUsages::SIGN | KeyUsages::VERIFY);

let kek = KeyPolicy::default_for(KeyAlgorithm::Aes256);
assert_eq!(kek.usages, KeyUsages::WRAP | KeyUsages::UNWRAP);

// Everything else is the restrictive default either way.
assert!(!kek.extractable);

Trait Implementations

impl Clone for KeyPolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyPolicy

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

Formats the value using the given formatter.

impl Default for KeyPolicy

fn default() -> Self

Most secure configuration for ceremony signing keys: persistent=true, sensitive=true, extractable=false, sign+verify only.

impl<'de> Deserialize<'de> for KeyPolicy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for KeyPolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.