Struct UnverifiedChannel

pub struct UnverifiedChannel<T: AsyncRead + AsyncWrite + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider> {
    sleep_prov: S,
    memquota: ChannelAccount,
    link_protocol: u16,
    tls: Framed<T, ChannelCodec<OpenChanMsgS2C, AnyChanMsg>>,
    certs_cell: Certs,
    target_method: Option<ChannelMethod>,
    netinfo_cell: Netinfo,
    clock_skew: ClockSkew,
    unique_id: UniqId,
}

A client channel on which versions have been negotiated and the relay’s handshake has been read, but where the certs have not been checked.

Fields

sleep_prov: S

Runtime handle (insofar as we need it)

memquota: ChannelAccount

Memory quota account

link_protocol: u16

The negotiated link protocol. Must be a member of LINK_PROTOCOLS

tls: Framed<T, ChannelCodec<OpenChanMsgS2C, AnyChanMsg>>

The Source+Sink on which we’re reading and writing cells.

certs_cell: Certs

The certs cell that we got from the relay.

target_method: Option<ChannelMethod>

Declared target method for this channel, if any.

netinfo_cell: Netinfo

The netinfo cell that we got from the relay.

clock_skew: ClockSkew

How much clock skew did we detect in this handshake?

This value is unauthenticated, since we have not yet checked whether the keys in the handshake are the ones we expected.

unique_id: UniqId

Logging identifier for this stream. (Used for logging only.)

Implementations

impl<T: AsyncRead + AsyncWrite + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider> UnverifiedChannel<T, S>

pub fn clock_skew(&self) -> ClockSkew

Return the reported clock skew from this handshake.

Note that the skew reported by this function might not be “true”: the relay might have its clock set wrong, or it might be lying to us.

The clock skew reported here is not yet authenticated; if you need to make sure that the skew is authenticated, use Channel::clock_skew instead.

pub fn check<U: ChanTarget + ?Sized>( self, peer: &U, peer_cert: &[u8], now: Option<SystemTime>, ) -> Result<VerifiedChannel<T, S>>

Validate the certificates and keys in the relay’s handshake.

‘peer’ is the peer that we want to make sure we’re connecting to.

‘peer_cert’ is the x.509 certificate that the peer presented during its TLS handshake (ServerHello).

‘now’ is the time at which to check that certificates are valid. None means to use the current time. It can be used for testing to override the current view of the time.

This is a separate function because it’s likely to be somewhat CPU-intensive.

fn check_internal<U: ChanTarget + ?Sized>( self, peer: &U, peer_cert_sha256: &[u8], now: Option<SystemTime>, ) -> Result<VerifiedChannel<T, S>>

Same as check, but takes the SHA256 hash of the peer certificate, since that is all we use.