Enum KeySecurity

#[repr(u8)]
pub enum KeySecurity {
    Weak = 0,
    Medium = 1,
    NotTracked = 2,
}

This indicates the security of the key by keeping track of whether the secret key material was handled carefully. If the secret is exposed in any way, or leaked and the memory not zeroed, the key security drops to Weak.

This is a Best Effort tag. There are ways to leak the key and still have this tag claim the key is Medium security. So Medium really means it might not have leaked, whereas Weak means we know that it definately did leak.

We offer no Strong security via the PrivateKey structure. If we support hardware tokens in the future, it will probably be via a different structure.

Variants

Weak = 0

This means that the key was exposed in a way such that this library cannot ensure it’s secrecy, usually either by being exported as a hex string, or by being imported from the same. Often in these cases it is displayed on the screen or left in the cut buffer or in freed memory that was not subsequently zeroed.

Medium = 1

This means that the key might not have been directly exposed. But it still might have as there are numerous ways you can leak it such as exporting it and then decrypting the exported key, using unsafe rust, transmuting it into a different type that doesn’t protect it, or using a privileged process to scan memory. Additionally, more advanced techniques can get at your key such as hardware attacks like spectre, rowhammer, and power analysis.

NotTracked = 2

Not tracked

Trait Implementations

impl Clone for KeySecurity

fn clone(&self) -> KeySecurity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeySecurity

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

Formats the value using the given formatter.

impl Hash for KeySecurity

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 KeySecurity

fn eq(&self, other: &KeySecurity) -> 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 TryFrom<u8> for KeySecurity

type Error = Error

The type returned in the event of a conversion error.

fn try_from(i: u8) -> Result<KeySecurity, Error>

Performs the conversion.

impl Copy for KeySecurity

impl Eq for KeySecurity

impl StructuralPartialEq for KeySecurity