Enum KeyStoreError 

#[non_exhaustive]
pub enum KeyStoreError {
    NotFound(KeyId),
    AlreadyExists(KeyId),
    AlgorithmMismatch {
        key: KeyId,
        key_alg: JwsAlgorithm,
        requested: JwsAlgorithm,
    },
    Unsupported(&'static str),
    UnsupportedAlgorithm(JwsAlgorithm),
    UnsupportedKeyType(KeyType),
    InvalidSpec {
        key_type: KeyType,
        alg: JwsAlgorithm,
    },
    InvalidKey {
        key: KeyId,
        reason: String,
        source: Option<Box<dyn Error + Send + Sync + 'static>>,
    },
    Io {
        path: PathBuf,
        source: Error,
    },
    InsecurePermissions {
        path: PathBuf,
        mode: u32,
    },
    InvalidKeySet {
        path: PathBuf,
        reason: String,
        source: Option<Box<dyn Error + Send + Sync + 'static>>,
    },
    Backend(Box<dyn Error + Send + Sync + 'static>),
}

Why a KeyStore operation failed.

The first variants are the contract every backend follows (the test suite checks them); the file variants are reported by SoftwareKeyStore, and Backend carries whatever a remote backend reports.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NotFound(KeyId)

No key has this id.

AlreadyExists(KeyId)

A key with this id exists already, so it cannot be generated or imported.

AlgorithmMismatch

The key signs with another algorithm than the one requested.

Fields

key: KeyId

The key.

key_alg: JwsAlgorithm

The algorithm the key was created for.

requested: JwsAlgorithm

The algorithm that was requested.

Unsupported(&'static str)

The backend does not implement this operation (generate or delete).

UnsupportedAlgorithm(JwsAlgorithm)

The backend does not sign with this algorithm; see KeyStoreCapabilities::algorithms.

UnsupportedKeyType(KeyType)

The backend cannot generate keys of this type.

InvalidSpec

The algorithm of a KeySpec does not fit its key type, for example ES256 with an Ed25519 key.

Fields

key_type: KeyType

The requested key type.

alg: JwsAlgorithm

The requested algorithm.

InvalidKey

The key exists but its material cannot be used: it does not decode, the public part does not match the private part, the type is unknown, and so on. The source is the error that says why, when there is one: the JwkError of a public key that does not convert to a JWK, the error of a private scalar out of range.

Fields

key: KeyId

The key.

reason: String

What is wrong with it.

source: Option<Box<dyn Error + Send + Sync + 'static>>

The underlying error.

Io

Reading or writing the key store file failed.

Fields

path: PathBuf

The file.

source: Error

The I/O error.

InsecurePermissions

The key store file is readable or writable by other users.

Fields

path: PathBuf

The file.

mode: u32

Its permission bits.

InvalidKeySet

The key store file is not a usable JWK set. The source is the JSON error, or the error that makes one of its keys unusable, when there is one.

Fields

path: PathBuf

The file.

reason: String

What is wrong with it.

source: Option<Box<dyn Error + Send + Sync + 'static>>

The underlying error.

Backend(Box<dyn Error + Send + Sync + 'static>)

An error of a remote backend (an HSM, a cloud service).

Implementations

impl KeyStoreError

pub fn invalid_key(key: KeyId, reason: impl Into<String>) -> Self

KeyStoreError::InvalidKey for key, without an underlying error.

pub fn backend<E: Error + Send + Sync + 'static>(error: E) -> Self

Wraps a backend’s own error as KeyStoreError::Backend.

Trait Implementations

impl Debug for KeyStoreError

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

Formats the value using the given formatter.

impl Display for KeyStoreError

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

Formats the value using the given formatter.

impl Error for KeyStoreError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<KeyStoreError> for IdentityError

fn from(source: KeyStoreError) -> Self

Converts to this type from the input type.