Enum XmlEncError 

#[non_exhaustive]
pub enum XmlEncError {
    Policy(PolicyViolation),
    Provider(ProviderError),
    XmlParse(Error),
    Document(XmlDocumentError),
    MissingRequired(&'static str),
    InvalidStructure(String),
    SelectedNodeUnavailable {
        id: String,
    },
    UnsupportedAlgorithm(String),
    Base64(String),
    DataTooShort {
        algorithm: &'static str,
        minimum: usize,
        actual: usize,
    },
    InvalidCbcCiphertextLength(usize),
    InvalidPadding,
    AeadAuthenticationFailed,
    InvalidKeySize {
        algorithm: DataEncryptionAlgorithm,
        expected: usize,
        actual: usize,
    },
    AmbiguousKeyCandidates {
        algorithm: DataEncryptionAlgorithm,
        actual: usize,
    },
    InvalidKekSize {
        algorithm: KeyWrapAlgorithm,
        expected: usize,
        actual: usize,
    },
    InvalidWrappedKeyLength {
        expected: usize,
        actual: usize,
    },
    InvalidEncryptionConfig(String),
    KeyNotFound,
    EncryptedDataNotFound,
    AmbiguousEncryptedData,
    EncryptionTargetNotFound,
    AmbiguousEncryptionTarget,
    ReplacementRequiresXml,
    Rsa(String),
    RsaEncrypt(String),
    KeyWrapIntegrity,
    Rng(String),
    XmlSerialize(String),
    Utf8(FromUtf8Error),
}

Errors raised while parsing, encrypting, resolving, or decrypting XMLEnc data.

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.

Policy(PolicyViolation)

The compiled encryption or decryption policy rejected an operation input.

Provider(ProviderError)

The selected cryptographic provider rejected or failed an operation.

XmlParse(Error)

XML document parsing failed.

Document(XmlDocumentError)

The owned XML document boundary rejected an identity or mutation.

MissingRequired(&'static str)

Required child element or attribute was absent.

InvalidStructure(String)

The XML element order or namespace is invalid for the XMLEnc profile.

SelectedNodeUnavailable

The selected operation-start node ID is absent or resolves ambiguously.

Fields

id: String

Caller-supplied node identifier.

UnsupportedAlgorithm(String)

An algorithm URI is not supported by this build.

Base64(String)

Base64 input is invalid or exceeds the configured input bound.

DataTooShort

A decoded cipher value is too short for its algorithm’s framing.

Fields

algorithm: &'static str

Algorithm name.

minimum: usize

Minimum valid byte length.

actual: usize

Actual byte length.

InvalidCbcCiphertextLength(usize)

CBC ciphertext is not a non-empty multiple of the AES block size.

InvalidPadding

XMLEnc random padding is invalid.

No decrypted padding details are exposed. This does not authenticate CBC ciphertexts or make success/failure safe to expose to an attacker.

AeadAuthenticationFailed

GCM authentication failed.

InvalidKeySize

A supplied content key is not the expected size.

Fields

algorithm: DataEncryptionAlgorithm

Content algorithm requiring the key.

expected: usize

Expected key size.

actual: usize

Actual key size.

AmbiguousKeyCandidates

An unauthenticated content algorithm cannot safely select among keys.

Fields

algorithm: DataEncryptionAlgorithm

Unauthenticated algorithm for which key success is ambiguous.

actual: usize

Number of unresolved candidate keys.

InvalidKekSize

A supplied AES key-encryption key is not the size declared by EncryptedKey.

Fields

algorithm: KeyWrapAlgorithm

Key-wrap algorithm requiring the KEK.

expected: usize

Expected KEK size.

actual: usize

Actual KEK size.

InvalidWrappedKeyLength

A wrapped-key input or provider output has invalid algorithm framing.

Fields

expected: usize

Exact wrapped length required by the algorithm and key context.

actual: usize

Actual input or provider output length.

InvalidEncryptionConfig(String)

Encryption configuration is internally inconsistent.

KeyNotFound

No caller-provided resolver could supply a usable key.

EncryptedDataNotFound

No EncryptedData matched the requested document selection.

AmbiguousEncryptedData

More than one EncryptedData matched the requested document selection.

EncryptionTargetNotFound

No source element matched the requested encryption target.

AmbiguousEncryptionTarget

More than one source element matched the requested encryption target.

ReplacementRequiresXml

Document replacement requires an XML Type declaration.

Rsa(String)

RSA-OAEP session-key recovery failed.

RsaEncrypt(String)

RSA-OAEP session-key wrapping failed.

KeyWrapIntegrity

RFC 3394 integrity validation failed while unwrapping a key.

Rng(String)

Operating-system randomness was unavailable.

XmlSerialize(String)

Generated XML could not be serialized.

Utf8(FromUtf8Error)

XML-declared plaintext could not be decoded as UTF-8.

Trait Implementations

impl Debug for XmlEncError

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

Formats the value using the given formatter.

impl Display for XmlEncError

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

Formats the value using the given formatter.

impl Error for XmlEncError

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<Error> for XmlEncError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for XmlEncError

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<PolicyViolation> for XmlEncError

fn from(source: PolicyViolation) -> Self

Converts to this type from the input type.

impl From<ProviderError> for XmlEncError

fn from(source: ProviderError) -> Self

Converts to this type from the input type.

impl From<XmlDocumentError> for XmlEncError

fn from(source: XmlDocumentError) -> Self

Converts to this type from the input type.