Struct chacha20stream::Sink

pub struct Sink<W> { /* fields omitted */ }

ChaCha Sink

Encryption

To create an encrypting wrapper stream:

let mut stream = Sink::encrypt(&mut backing_stream, key, iv).expect("Failed to create encryptor");
/* do work with `stream` */

// It is recommended to `flush` the stream to clear out any remaining data in the internal transformation buffer.
stream.flush().unwrap();

Decryption

To create a decrypting wrapper stream:

let mut stream = Sink::decrypt(&mut backing_stream, key, iv).expect("Failed to create decryptor");
/* do work with `stream` */

// It is recommended to `flush` the stream to clear out any remaining data in the internal transformation buffer.
stream.flush().unwrap();

Note

When writing, a temporary buffer stored in the structure is used. This buffer is not cleared after a write, for efficiency reasons. This may leave sensitive information in the buffer after the write operation. The flush() implementation does clear this buffer. You can use the prune() function to zero out this buffer manually too.

Implementations

impl<W> Sink<W> where
    W: Write, 

pub fn encrypt(stream: W, key: Key, iv: IV) -> Result<Self, ErrorStack>

Create an encrypting Chacha Sink stream wrapper

pub fn decrypt(stream: W, key: Key, iv: IV) -> Result<Self, ErrorStack>

Create a decrypting Chacha Sink stream wrapper

pub fn into_inner(self) -> W

Consume into the inner stream

pub fn into_parts(self) -> (W, Crypter)

Consume into the inner stream and crypter

pub fn crypter(&self) -> &Crypter

The crypter of this instance

pub fn crypter_mut(&mut self) -> &mut Crypter

The crypter of this instance

pub fn inner(&self) -> &W

The inner stream

pub fn inner_mut(&mut self) -> &mut W

The inner stream

pub fn prune(&mut self)

Clear the internal buffer while keeping it allocated for further use.

This does not affect operations at all, all it does is 0 out the left-over temporary buffer from the last operation(s).

Trait Implementations

impl<W: Debug> Debug for Sink<W>

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

Formats the value using the given formatter.

impl<W: Write> Write for Sink<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

pub fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

pub fn write_all_vectored(
    &mut self,
    bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

pub fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Write.