Struct Claimed 

pub struct Claimed<I: Identity> { /* private fields */ }

A chain whose peer has claimed a static — §6.1’s stage 1, at 1 DH cumulative.

The claim is not proof. Drop is a silent reject.

S8 — #[must_use], see Intro. This is the stage S8 names explicitly, the one parked across turns while a human is asked.

Implementations

impl<I: Identity> Claimed<I>

pub fn claimed_static(&self) -> &PublicKeyOf<I>

The static the peer claims.

Named claimed_static, never remote_static, and the name is the documentation: at this stage possession has not been proven. §6.1’s ss in authenticate is what proves it.

pub async fn authenticate(self) -> Result<Proven<I>, AuthError>

where I::Suite: Handshake<Psk = ()>,

§6.1’s stage 2 — +1 DH (ss), 2 cumulative.

Possession is proven here, and §17.1’s timestamp guard admits the initiation here. On any error the chain is discarded, for the reason given on Intro::read_identity.

Cancel-safe on the same terms as Intro::read_identity: a dropped future rejects the chain rather than orphaning it.

Defined only where the suite’s pattern has no pre-shared key; a channel_psk! suite has authenticate_with instead.

pub async fn authenticate_with( self, psk: PskOf<I>, ) -> Result<Proven<I>, AuthError>

authenticate, naming the pre-shared key.

This is the stage the PSK belongs at, and the reason is the cost

claimed_static is already in your hand — one es, and nothing else, has been spent — so the key is selected with the peer named. That ordering is the whole reason the pattern is IKpsk1 and not a psk0 shape: its psk token sits after msg1’s s, so a stranger you have no key for is rejected by dropping this object, at 1 DH. Choosing inside the handshake instead — hiss’s read_message_1_with lookup closure, which fires at the psk token and therefore after the proving ss — would cost 2 (ruling 280).

This is also why the key is not held by the endpoint: an endpoint that already knew which PSK to use would have no use for the identity this stage exists to reveal.

A wrong key is AuthError::HandshakeFailed

The same undetailed verdict a forged identity gets, and the same 2 DH. “You are not who you claim” and “you do not hold the pairing secret” are one answer to one question, and §18.1 gives an unauthenticated peer no oracle for telling them apart.

Cancel-safe on the same terms as authenticate.

Trait Implementations

impl<I: Identity> Debug for Claimed<I>

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

Formats the value using the given formatter.

impl<I: Identity> Drop for Claimed<I>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.