Consider supporting buffer-to-buffer cipher operations

[newpavlov]

For some use-cases (e.g. in TLS implementations) you need to decrypt/encrypt data from read-only source and write result into provided buffer.

To prevent code duplication I think the best solution will be to implement algorithms over enum like this:

enum CryptoBuf<'a> {
    InBuf(&'a mut [u8]),
    BufToBuf { in_buf: &'a [u8], out_buf: &'a mut [u8] },
}

trait Cipher: Sized {
    /// Users are heavily discouraged from using this method
    fn _encrypt(self, data: CryptoBuf);
    fn encrypt(self, buf: &mut [u8]) {
        self._encrypt(CryptoBuf::InBuf(buf));
    }
    fn encrypt_b2b(self, in_buf: &mut [u8], out_buf: &mut [u8]) -> Result<(), Error> {
        if check_lengths(in_buf, out_buf) { Err(Error)? }
        self._encrypt(CryptoBuf::BufToBuf { in_buf, out_buf });
        Ok(())
    }
}

Any thoughts?

[tarcieri]

Isn't the general idea more simply expressed as:

in_buf: Option<&'a [u8]>

...with the idea being that if in_buf is None, then out_buf is also the input buffer?

[newpavlov]

Hm, you are right, but I think using a separate enum will be more ergonomic (for algorithm implementations), e.g. we will be able to offload to it a lot of common functionality, like: reading, writing, indexing, slicing, ensuring that buffers have equal length, etc.

I think it also could be worth to think about how we could integrate Read and Write here.