Struct ffsend_api::reader::EncryptedFileReader

pub struct EncryptedFileReader { /* fields omitted */ }

A lazy file reader, that encrypts the file with the given cipher and appends the cryptographic tag to the end of it.

This reader is lazy because the file data loaded from the system and encrypted when it is read from the reader. This greatly reduces memory usage for large files.

This reader encrypts the file data with an appended cryptographic tag.

The reader uses a small internal buffer as data is encrypted in blocks, which may output more data than fits in the given buffer while reading. The excess data is then returned on the next read.

Methods

impl EncryptedFileReader

pub fn new(
    file: File,
    cipher: Cipher,
    key: &[u8],
    iv: &[u8]
) -> Result<Self, Error>

Construct a new reader for the given file with the given cipher.

This method consumes twice the size of the file in memory while constructing, and constructs a reader that has a size similar to the file.

It is recommended to wrap this reader in some sort of buffer, such as: std::io::BufReader

Trait Implementations

impl ExactLengthReader for EncryptedFileReader

fn len(&self) -> Result<u64, Error>

Calculate the total length of the encrypted file with the appended tag. Useful in combination with some progress monitor, to determine how much of the file is read or for example; sent over the network.

fn is_empty(&self) -> Result<bool, Error>

Check whehter this extact length reader is emtpy.

impl Read for EncryptedFileReader

The reader trait implementation.

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

Read from the encrypted file, and then the encryption tag.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Creates a "by reference" adaptor for this instance of Read.

Important traits for Bytes<R>

impl<R> Iterator for Bytes<R> where
    R: Read,  type Item = Result<u8, Error>;

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

Important traits for Chars<R>

impl<R> Iterator for Chars<R> where
    R: Read,  type Item = Result<char, CharsError>;

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

Important traits for Chain<T, U>

impl<T, U> Read for Chain<T, U> where
    T: Read,
    U: Read, 

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

Important traits for Take<T>

impl<T> Read for Take<T> where
    T: Read, 

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl Send for EncryptedFileReader