Enum DpopError 

pub enum DpopError {
    MoreThanOneProof,
    Malformed,
    InvalidEncoding(&'static str),
    MissingClaim(&'static str),
    JtiTooLong {
        length: usize,
    },
    WrongTyp(Option<String>),
    UnsupportedAlgorithm(String),
    UnsupportedKey,
    BadSignature,
    MethodMismatch {
        proof: String,
        expected: String,
    },
    UriMismatch {
        proof: String,
        expected: String,
    },
    ClockSkew {
        iat: OffsetDateTime,
        now: OffsetDateTime,
        window: Duration,
    },
    PredatesStart {
        iat: OffsetDateTime,
        started: OffsetDateTime,
    },
    Replayed {
        jti: String,
    },
    ReplayWindowFull,
    ThumbprintMismatch,
    AccessTokenHashMismatch,
    NonceRequired {
        fresh: String,
    },
    NonceMismatch {
        fresh: String,
    },
}

Why a presented DPoP proof, or the binding it claims, was refused.

Each variant names the one check that failed rather than folding every failure into a single “invalid proof” – in particular DpopError::ClockSkew carries both timestamps and the window, so a refusal caused by clock drift between two honest clocks reads as exactly that rather than as a forged signature.

Variants

MoreThanOneProof

The request carried more than one DPoP header.

Malformed

Not three .-separated segments.

InvalidEncoding(&'static str)

A segment was not valid, unpadded base64url, or the JSON it decoded to did not have the shape this module reads. The &'static str names which segment.

MissingClaim(&'static str)

A required claim (jti, htm, htu, or iat) was absent.

JtiTooLong

The jti is longer than MAX_JTI_BYTES, so the replay window will not keep it.

Fields

length: usize

How long it was, in bytes.

WrongTyp(Option<String>)

typ was missing, or present and not "dpop+jwt".

UnsupportedAlgorithm(String)

alg was not "ES256".

UnsupportedKey

The embedded jwk did not name an EC P-256 key with well-formed x and y members, or did not decode to a point on the curve.

BadSignature

The signature did not verify over header.payload.

MethodMismatch

htm did not match the request’s method.

Fields

proof: String

What the proof claimed.

expected: String

What the request actually was.

UriMismatch

htu did not match the request’s target, once both are normalized (query and fragment dropped, scheme and host lowercased).

Fields

proof: String

What the proof claimed.

expected: String

What the caller told this verifier to expect.

ClockSkew

iat fell outside the accepted clock-skew window.

Fields

iat: OffsetDateTime

The proof’s own iat, as an absolute time.

now: OffsetDateTime

This verifier’s own clock at the moment it checked.

window: Duration

The window on either side of now that would have been accepted.

PredatesStart

The proof was stamped before this verifier began accepting proofs, and it is still inside the first clock-skew window since. Its own refusal rather than DpopError::ClockSkew, because the clocks agree: the proof is simply older than the replay window can speak for.

Fields

iat: OffsetDateTime

The proof’s own iat, as an absolute time.

started: OffsetDateTime

When this verifier began accepting proofs.

Replayed

This jti was already accepted once, inside the window during which it is still considered fresh.

Fields

jti: String

The repeated jti.

ReplayWindowFull

The replay window is holding as many jtis as it will, so this verifier cannot promise this one has not been seen. Refused rather than admitted: a replay cache that forgets to make room is a replay cache that lets one through. See REPLAY_CAPACITY.

ThumbprintMismatch

A binding was requested (expected_thumbprint in DpopVerifier::verify) and the proof’s key does not have it.

AccessTokenHashMismatch

An access token was supplied to check against and the proof’s ath does not hash to it – either absent or wrong.

NonceRequired

This verifier requires a nonce and the proof carried none. The client resolves this by retrying with the carried nonce, which is now the only nonce this verifier accepts.

Fields

fresh: String

The nonce to retry with.

NonceMismatch

A nonce was presented and it is not one this verifier currently accepts. Same resolution as DpopError::NonceRequired.

Fields

fresh: String

The nonce to retry with.

Implementations

impl DpopError

pub fn fresh_nonce(&self) -> Option<&str>

The nonce a client should retry with, for the two refusals that carry one.

Trait Implementations

impl Clone for DpopError

fn clone(&self) -> DpopError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DpopError

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

Formats the value using the given formatter.

impl Display for DpopError

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

Formats the value using the given formatter.

impl Error for DpopError

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 PartialEq for DpopError

fn eq(&self, other: &DpopError) -> 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 Eq for DpopError

impl StructuralPartialEq for DpopError