Struct UnverifiedChannel 

pub(crate) struct UnverifiedChannel<T: AsyncRead + AsyncWrite + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider> {
    pub(crate) sleep_prov: S,
    pub(crate) memquota: ChannelAccount,
    pub(crate) link_protocol: u16,
    pub(crate) framed_tls: Framed<T, ChannelCellHandler>,
    pub(crate) target_method: Option<ChannelMethod>,
    pub(crate) clock_skew: ClockSkew,
    pub(crate) unique_id: UniqId,
}

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

Both relay and client have specialized objects for an unverified channel which include this one as the base in order to share functionalities.

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

framed_tls: Framed<T, ChannelCellHandler>

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

target_method: Option<ChannelMethod>

Declared target method for this channel, if any.

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(crate) fn into_verified( self, peer_relay_ids: RelayIds, peer_rsa_id_digest: [u8; 32], ) -> VerifiedChannel<T, S>

Return a newly constructed VerifiedChannel.

pub(crate) fn check_relay_identities<U: ChanTarget + ?Sized>( &self, peer_target: &U, peer_certs: &Certs, now: SystemTime, ) -> Result<(RelayIds, Ed25519Identity, [u8; 32])>

This validates the relay identities (Ed25519 and RSA) and signing key cert (Ed25519) found in the received msg::Certs cell. It also enforces that the peer claimed IDs are the one we expected (peer_target).

Successful validation returns the relay ed25519 identitiy key, the ed25519 signing key and the RSA public key of the peer. This means that we consider the peer verified as in we’ve established that we are talking to the right target.

Reason for the RSA public key is because the caller needs the SHA256 digest for the msg::Authenticate cell.

pub(crate) fn finish( self, peer_netinfo: &Netinfo, my_addrs: &[IpAddr], peer_info: MaybeSensitive<PeerInfo>, channel_mode: ChannelMode, ) -> Result<(Arc<Channel>, Reactor<S>)>

where S: Runtime,

Finalize this channel into an actual channel and its reactor.

An unverified channel can be finalized as it skipped the cert verification and authentication because simply the other side is not authenticating.

Two cases for this: - Client <-> Relay channel - Bridge <-> Relay channel

peer_netinfo is the received msg::Netinfo cell from the peer.

my_addrs are our advertised addresses as a relay.

peer_info is the verified peer information (identities and addresses).