Enum ChallengeClass 

pub enum ChallengeClass {
    None,
    Interstitial,
    Captcha,
    ProofOfWork,
    IntegrityCheck,
    CookieRefresh,
    Unknown,
}

Stable label for the kind of challenge a token is bound to.

The taxonomy mirrors the surfaces a challenge token can be issued for. It is intentionally smaller than the ChallengeOutcome enum (T83) because outcomes describe what the runner observed on the wire, while ChallengeClass describes what the token is for. A Captcha outcome and a Captcha token challenge class are paired by construction — but a Captcha token can also be observed against an IntegrityCheck outcome when the vendor re-checks the captcha solution during a follow-up request.

Example

use stygian_charon::token_lifecycle::ChallengeClass;

let c = ChallengeClass::Captcha;
assert_eq!(c.label(), "captcha");
assert!(c.requires_nonce());

Variants

None

No challenge — token is a session cookie or bearer-style bearer that does not gate a specific challenge artefact.

Interstitial

Soft / interstitial challenge (e.g. cf-chl-bypass for Cloudflare’s “Just a moment…” page).

Captcha

Captcha challenge (reCAPTCHA, hCaptcha, DataDome captcha-delivery, etc.).

ProofOfWork

Proof-of-work challenge (e.g. Akamai _abck derivation).

IntegrityCheck

JS integrity check (e.g. PerimeterX _px3 payload).

CookieRefresh

Cookie refresh / sticky session roll-over.

Unknown

Catch-all when the challenge class cannot be classified.

Implementations

impl ChallengeClass

pub const fn label(self) -> &'static str

Stable, lower-case wire label.

Example

use stygian_charon::token_lifecycle::ChallengeClass;

assert_eq!(ChallengeClass::Interstitial.label(), "interstitial");
assert_eq!(ChallengeClass::Captcha.label(), "captcha");
assert_eq!(ChallengeClass::ProofOfWork.label(), "proof_of_work");
assert_eq!(ChallengeClass::IntegrityCheck.label(), "integrity_check");
assert_eq!(ChallengeClass::CookieRefresh.label(), "cookie_refresh");
assert_eq!(ChallengeClass::None.label(), "none");
assert_eq!(ChallengeClass::Unknown.label(), "unknown");

pub const fn requires_nonce(self) -> bool

Whether the validator must enforce nonce binding for tokens of this challenge class.

Every class except None requires a nonce. None is the “session cookie” path — the cookie itself is the contract and nonce binding is meaningless.

Example

use stygian_charon::token_lifecycle::ChallengeClass;

assert!(!ChallengeClass::None.requires_nonce());
assert!(ChallengeClass::Interstitial.requires_nonce());
assert!(ChallengeClass::Captcha.requires_nonce());

pub const fn requires_session_binding(self) -> bool

Whether the validator must enforce session binding for tokens of this challenge class.

Only the cookie-refresh / sticky-session class is sensitive to session binding by default; all other classes are session-agnostic. Per-vendor policy overrides can still require session binding for any class.

Example

use stygian_charon::token_lifecycle::ChallengeClass;

assert!(ChallengeClass::CookieRefresh.requires_session_binding());
assert!(!ChallengeClass::Interstitial.requires_session_binding());

Trait Implementations

impl Clone for ChallengeClass

fn clone(&self) -> ChallengeClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChallengeClass

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChallengeClass

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ChallengeClass

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 ChallengeClass

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ChallengeClass

impl Eq for ChallengeClass

impl StructuralPartialEq for ChallengeClass