Struct quinn_noise::NoiseSession

pub struct NoiseSession { /* fields omitted */ }

Trait Implementations

impl ClientConfig<NoiseSession> for NoiseConfig

fn new() -> Self

Construct the default configuration

fn start_session(
    &self,
    _: &str,
    params: &TransportParameters
) -> Result<NoiseSession, ConnectError>

Start a client session with this configuration

impl Session for NoiseSession

type HandshakeData = ()

Parameters determined when the handshake begins, e.g. server name and/or application protocol

type Identity = PublicKey

Cryptographic identity of the peer

type ClientConfig = NoiseConfig

Type used to hold configuration for client sessions

type ServerConfig = Arc<NoiseConfig>

Type used to hold configuration for server sessions

type HmacKey = Key

Type used to sign various values

type HandshakeTokenKey = Prk

Key used to generate one-time-use handshake token keys

type HeaderKey = PlaintextHeaderKey

Type of keys used to protect packet headers

type PacketKey = ChaCha8PacketKey

Type used to represent packet protection keys

fn initial_keys(_: &ConnectionId, _: Side) -> Keys<Self>

Create the initial set of keys given the client’s initial destination ConnectionId

fn next_1rtt_keys(&mut self) -> KeyPair<Self::PacketKey>

Compute keys for the next key update

fn read_handshake(&mut self, handshake: &[u8]) -> Result<bool, TransportError>

Read bytes of handshake data

fn write_handshake(&mut self, handshake: &mut Vec<u8>) -> Option<Keys<Self>>

Writes handshake bytes into the given buffer and optionally returns the negotiated keys

fn is_handshaking(&self) -> bool

Returns true until the connection is fully established.

fn peer_identity(&self) -> Option<Self::Identity>

Get the peer’s identity, if available

fn transport_parameters(
    &self
) -> Result<Option<TransportParameters>, TransportError>

The peer’s QUIC transport parameters

fn handshake_data(&self) -> Option<Self::HandshakeData>

Get data negotiated during the handshake, if available

fn export_keying_material(
    &self,
    output: &mut [u8],
    label: &[u8],
    context: &[u8]
) -> Result<(), ExportKeyingMaterialError>

Fill output with output.len() bytes of keying material derived from the Session’s secrets, using label and context for domain separation.

fn early_crypto(&self) -> Option<(Self::HeaderKey, Self::PacketKey)>

Get the 0-RTT keys if available (clients only)

fn early_data_accepted(&self) -> Option<bool>

If the 0-RTT-encrypted data has been accepted by the peer

fn retry_tag(orig_dst_cid: &ConnectionId, packet: &[u8]) -> [u8; 16]

Generate the integrity tag for a retry packet

fn is_valid_retry(
    orig_dst_cid: &ConnectionId,
    header: &[u8],
    payload: &[u8]
) -> bool

Verify the integrity of a retry packet