Struct ChannelAuthenticationData 

pub(crate) struct ChannelAuthenticationData {
    pub(crate) link_auth: u16,
    pub(crate) cid: [u8; 32],
    pub(crate) sid: [u8; 32],
    pub(crate) cid_ed: [u8; 32],
    pub(crate) sid_ed: [u8; 32],
    pub(crate) clog: ClogDigest,
    pub(crate) slog: SlogDigest,
    pub(crate) scert: [u8; 32],
}

Channel authentication data. This is only relevant for a Relay to Relay channel which are authenticated using this buffet of bytes.

Fields

link_auth: u16

Authentication method to use.

cid: [u8; 32]

SHA256 digest of the initiator KP_relayid_rsa.

sid: [u8; 32]

SHA256 digest of the responder KP_relayid_rsa.

cid_ed: [u8; 32]

The initiator KP_relayid_ed.

sid_ed: [u8; 32]

The responder KP_relayid_ed.

clog: ClogDigest

Initiator log SHA256 digest.

slog: SlogDigest

Responder log SHA256 digest.

scert: [u8; 32]

SHA256 of responder’s TLS certificate.

Implementations

impl ChannelAuthenticationData

const fn auth_type_bytes(link_auth: u16) -> Result<&'static [u8]>

Helper: return the authentication type string from the given link auth version.

const fn keying_material_label_bytes(link_auth: u16) -> Result<&'static [u8]>

Helper: return the keying material label from the given link auth version.

pub(crate) fn as_body_no_rand<C: CertifiedConn>( &self, tls: &C, ) -> Result<Vec<u8>>

Return a vector of bytes of an msg::Authenticate cell but without the random bytes and the signature.

This is needed so a responder can compare what is expected from what it got. A responder can only verify the signature and so we can’t compare the full msg::Authenticate message we received with what we expect.

pub(crate) fn into_authenticate<C: CertifiedConn>( self, tls: &C, link_ed: &RelayLinkSigningKeypair, ) -> Result<Authenticate>

Consume ourself and return an AUTHENTICATE cell from the data we hold.

pub(crate) fn build_initiator<T, S>( auth_challenge_cell: &AuthChallenge, auth_material: &Arc<RelayChannelAuthMaterial>, clog: ClogDigest, slog: SlogDigest, verified: &mut VerifiedChannel<T, S>, peer_cert_digest: [u8; 32], ) -> Result<ChannelAuthenticationData>

where T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider,

Build a ChannelAuthenticationData for an initiator channel handshake.

auth_challenge_cell is the msg::AuthChallenge we recevied during the handshake.

identities are our RelayChannelAuthMaterial

verified is a VerifiedChannel which we need to consume the CLOG/SLOG

peer_cert_digest is the TLS certificate presented by the peer.

pub(crate) fn build_responder( initiator_auth_type: u16, auth_material: &Arc<RelayChannelAuthMaterial>, clog: ClogDigest, slog: SlogDigest, peer_rsa_id_digest: [u8; 32], peer_relayid_ed: Ed25519Identity, our_cert_digest: [u8; 32], ) -> Result<ChannelAuthenticationData>

Build a ChannelAuthenticationData for a responder channel handshake.

initiator_auth_type is the authentication type from the msg::Authenticate received from the initiator.

auth_material are our RelayChannelAuthMaterial

verified is a VerifiedChannel which we need to consume the CLOG/SLOG

our_cert_digest is our TLS certificate that we presented as a channel responder.

IMPORTANT: The CLOG and SLOG from the framed_tls codec is consumed here so calling twice build_auth_data() will result in different AUTHENTICATE cells.