Struct internet2::NoiseTranscoder

pub struct NoiseTranscoder<const LEN_SIZE: usize> {
    pub encryptor: NoiseEncryptor<LEN_SIZE>,
    pub decryptor: NoiseDecryptor<LEN_SIZE>,
}

Returned after a successful handshake to encrypt and decrypt communication with peer nodes. It should not normally be manually instantiated. Automatically handles key rotation. For decryption, it is recommended to call decrypt_message_stream for automatic buffering.

Fields

encryptor: NoiseEncryptor<LEN_SIZE>

decryptor: NoiseDecryptor<LEN_SIZE>

Implementations

impl<const LEN_SIZE: usize> NoiseTranscoder<LEN_SIZE>

pub fn with(
sending_key: [u8; 32],
receiving_key: [u8; 32],
chaining_key: [u8; 32],
remote_pubkey: PublicKey
) -> Self

Instantiate a new Conduit with specified sending and receiving keys

pub fn remote_pubkey(&self) -> PublicKey

pub fn encrypt_buf(&mut self, buffer: &[u8]) -> Result<Vec<u8>, EncryptionError>

Encrypt data to be sent to peer

pub fn read_buf(&mut self, data: &[u8])

pub fn decrypt_single_message(
&mut self,
new_data: Option<&[u8]>
) -> Result<Option<Vec<u8>>, EncryptionError>

Decrypt a single message. If data containing more than one message has been received, only the first message will be returned, and the rest stored in the internal buffer. If a message pending in the buffer still hasn’t been decrypted, that message will be returned in lieu of anything new, even if new data is provided.

Trait Implementations

impl<const LEN_SIZE: usize> Bipolar for NoiseTranscoder<LEN_SIZE>

type Left = <NoiseTranscoder<LEN_SIZE> as Transcode>::Decryptor

First separable type (like reader)

type Right = <NoiseTranscoder<LEN_SIZE> as Transcode>::Encryptor

Second separable type (like writer)

fn join(decryptor: Self::Left, encryptor: Self::Right) -> Self

Reconstruct the type from the halves

fn split(self) -> (Self::Left, Self::Right)

Split the type into two

impl<const LEN_SIZE: usize> Debug for NoiseTranscoder<LEN_SIZE>

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

Formats the value using the given formatter.

impl<const LEN_SIZE: usize> Decrypt for NoiseTranscoder<LEN_SIZE>

type Error = HandshakeError

fn decrypt(&mut self, buffer: impl Borrow<[u8]>) -> Result<Vec<u8>, Self::Error>

impl<const LEN_SIZE: usize> Encrypt for NoiseTranscoder<LEN_SIZE>

fn encrypt(&mut self, buffer: impl Borrow<[u8]>) -> Vec<u8>

impl<const LEN_SIZE: usize> Transcode for NoiseTranscoder<LEN_SIZE>

type Encryptor = NoiseEncryptor<LEN_SIZE>

type Decryptor = NoiseDecryptor<LEN_SIZE>