Enum StryptError 

#[non_exhaustive]
pub enum StryptError {
    Io {
        action: IoAction,
        source: Error,
    },
    InputTooLarge {
        limit: u64,
        actual: Option<u64>,
    },
    UnsupportedFormat {
        format: UnsupportedKind,
    },
    UnrecognisedFormat,
    Malformed {
        format: Format,
        offset: Option<u64>,
        detail: MalformedDetail,
    },
    LimitExceeded {
        format: Format,
        limit: ResourceLimit,
    },
    VerificationFailed {
        format: Format,
        residual: usize,
    },
}

Everything that can go wrong in strypt-core.

Non-exhaustive: new variants are additive and must not break front-ends that match on it.

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.

Io

The underlying I/O operation failed.

action says what was being attempted, so a front-end can render “could not read the input” rather than a bare ENOENT.

Fields

action: IoAction

What the operation was trying to do.

source: Error

The operating system’s error.

InputTooLarge

The input exceeds the configured size limit and was not read.

This is a refusal, not a failure: an unbounded read of an attacker-supplied file is a memory-exhaustion vector (docs/ARCHITECTURE.md §5.1), so strypt declines rather than trying and dying.

Fields

limit: u64

The limit that was exceeded, in bytes.

actual: Option<u64>

The input’s actual size, where the source could report it.

UnsupportedFormat

The content was recognised, but no handler for it exists in this release.

Reported explicitly and never silently passed through — a silent pass-through is the failure mode in docs/THREAT_MODEL.md §5.4, where the user publishes a file the tool implied it had cleaned.

Fields

format: UnsupportedKind

What the content was identified as.

UnrecognisedFormat

The content matched no format strypt recognises at all.

Malformed

The file claims to be format but violates its structure.

Fields

format: Format

The format whose rules were broken.

offset: Option<u64>

Where the parser gave up, when the position is known.

detail: MalformedDetail

Which structural rule was violated. Never contains a metadata value.

LimitExceeded

A hostile or pathological file hit one of the parser’s resource ceilings.

For memory-safe Rust this is the realistic residual attack class, not memory corruption (docs/THREAT_MODEL.md §5.1), so it gets its own variant rather than being folded into StryptError::Malformed.

Fields

format: Format

The format being parsed when the ceiling was hit.

limit: ResourceLimit

Which ceiling.

VerificationFailed

The handler produced output, but re-inspecting that output still found metadata.

The output is discarded. This is the verification pass in docs/ARCHITECTURE.md §1 doing its job: it converts a silent handler bug into a loud, safe failure, which is the whole reason it exists.

Fields

format: Format

The format that was being stripped.

residual: usize

How many items the re-inspection still found. Counts only — never the values.

Trait Implementations

impl Debug for StryptError

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

Formats the value using the given formatter.

impl Display for StryptError

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

Formats the value using the given formatter.

impl Error for StryptError

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.