use std::io::{self, Read, Write};
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{BlockEncrypt, InnerIvInit, KeyInit, StreamCipher};
use aes::{Aes128, Aes192, Aes256};
use blowfish::Blowfish;
use cbc::cipher::{BlockDecryptMut, KeyIvInit as CbcKeyIvInit};
use cfb_mode::BufDecryptor;
use ctr::{flavors, Ctr32BE, CtrCore};
use ghash::universal_hash::UniversalHash;
use ghash::{Block as GhashBlock, GHash, Key as GhashKey};
use miniz_oxide::deflate::core::{
compress, create_comp_flags_from_zip_params, CompressorOxide, TDEFLFlush, TDEFLStatus,
};
use miniz_oxide::inflate::core::{decompress, inflate_flags, DecompressorOxide};
use miniz_oxide::inflate::TINFLStatus;
use secure_gate::{Dynamic, Fixed, RevealSecret, RevealSecretMut};
use sha1::{Digest, Sha1};
use sha2::Sha256;
use crate::limits::{AES_BLOCK_LEN, AES_GCM_IV_LEN, AES_GCM_TAG_LEN, CHECKSUM_WINDOW};
use crate::types::Checksum;
pub(crate) const CHUNK: usize = 64 * 1024;
const INFLATE_WINDOW: usize = 32 * 1024;
pub(crate) type ChunkBuffer = Dynamic<[u8]>;
#[derive(Debug)]
pub(crate) enum Fault {
WrongPassword,
Changed,
BadParameters(crate::BadParameter),
Internal(&'static str),
Inflate(String),
OutputLimit,
Alloc(usize),
Deflate(String),
}
impl std::fmt::Display for Fault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Fault::WrongPassword => f.write_str("wrong password"),
Fault::Changed => f.write_str("input changed between passes"),
Fault::BadParameters(b) => write!(f, "{b}"),
Fault::Internal(s) => f.write_str(s),
Fault::Inflate(s) => f.write_str(s),
Fault::OutputLimit => f.write_str("output limit exceeded"),
Fault::Alloc(n) => write!(f, "could not allocate {n} bytes"),
Fault::Deflate(s) => write!(f, "deflate failed: {s}"),
}
}
}
impl std::error::Error for Fault {}
impl Fault {
pub(crate) fn into_io(self) -> io::Error {
io::Error::other(self)
}
pub(crate) fn take(err: io::Error) -> Result<Fault, io::Error> {
if !err.get_ref().is_some_and(|e| e.is::<Fault>()) {
return Err(err);
}
let kind = err.kind();
match err.into_inner() {
Some(inner) => inner
.downcast::<Fault>()
.map(|f| *f)
.map_err(|other| io::Error::new(kind, other)),
None => Err(kind.into()),
}
}
}
pub(crate) fn chunk_buffer(n: usize) -> Result<ChunkBuffer, Fault> {
let mut v = Vec::new();
v.try_reserve_exact(n).map_err(|_| Fault::Alloc(n))?;
v.resize(n, 0);
Ok(Dynamic::from(v.into_boxed_slice()))
}
fn read_full<R: Read + ?Sized>(r: &mut R, buf: &mut [u8]) -> io::Result<usize> {
let mut n = 0;
while n < buf.len() {
match r.read(&mut buf[n..]) {
Ok(0) => break,
Ok(k) => n += k,
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) => return Err(e),
}
}
Ok(n)
}
pub(crate) fn ct_eq(got: &[u8], want: &[u8]) -> bool {
if got.len() != want.len() {
return false;
}
let mut diff = 0u8;
for (&a, &b) in got.iter().zip(want.iter()) {
diff |= a ^ b;
}
diff == 0
}
enum Ctr {
A128(Ctr32BE<Aes128>),
A192(Ctr32BE<Aes192>),
A256(Ctr32BE<Aes256>),
}
impl Ctr {
fn apply(&mut self, buf: &mut [u8]) {
match self {
Ctr::A128(c) => c.apply_keystream(buf),
Ctr::A192(c) => c.apply_keystream(buf),
Ctr::A256(c) => c.apply_keystream(buf),
}
}
}
struct GhashStream {
h: GHash,
partial: [u8; 16],
partial_len: usize,
ct_len: u64,
}
impl GhashStream {
fn update(&mut self, mut data: &[u8]) {
self.ct_len += data.len() as u64;
if self.partial_len > 0 {
let take = (16 - self.partial_len).min(data.len());
self.partial[self.partial_len..self.partial_len + take].copy_from_slice(&data[..take]);
self.partial_len += take;
data = &data[take..];
if self.partial_len < 16 {
return;
}
self.h.update(&[GhashBlock::from(self.partial)]);
self.partial_len = 0;
}
let whole = data.len() - data.len() % 16;
self.h.update_padded(&data[..whole]);
let rest = &data[whole..];
self.partial[..rest.len()].copy_from_slice(rest);
self.partial_len = rest.len();
}
fn finalize(mut self) -> [u8; 16] {
if self.partial_len > 0 {
self.h.update_padded(&self.partial[..self.partial_len]);
}
let mut lengths = [0u8; 16];
lengths[8..].copy_from_slice(&(self.ct_len * 8).to_be_bytes());
self.h.update(&[GhashBlock::from(lengths)]);
self.h.finalize().into()
}
}
pub(crate) struct GcmStream {
ctr: Ctr,
ghash: GhashStream,
tag_mask: Fixed<[u8; 16]>,
}
impl GcmStream {
pub(crate) fn new(key: &[u8], iv: &[u8]) -> Option<Self> {
if iv.len() != AES_GCM_IV_LEN {
return None;
}
let mut j0 = GenericArray::default();
j0[..AES_GCM_IV_LEN].copy_from_slice(iv);
j0[15] = 1;
let mut h = GenericArray::default();
let ctr = match key.len() {
16 => {
let c = Aes128::new_from_slice(key).ok()?;
c.encrypt_block(&mut h);
Ctr::A128(Ctr32BE::from_core(
CtrCore::<_, flavors::Ctr32BE>::inner_iv_init(c, &j0),
))
}
24 => {
let c = Aes192::new_from_slice(key).ok()?;
c.encrypt_block(&mut h);
Ctr::A192(Ctr32BE::from_core(
CtrCore::<_, flavors::Ctr32BE>::inner_iv_init(c, &j0),
))
}
32 => {
let c = Aes256::new_from_slice(key).ok()?;
c.encrypt_block(&mut h);
Ctr::A256(Ctr32BE::from_core(
CtrCore::<_, flavors::Ctr32BE>::inner_iv_init(c, &j0),
))
}
_ => return None,
};
let mut h_key = GhashKey::default();
h_key.copy_from_slice(&h);
let ghash = GhashStream {
h: GHash::new(&h_key),
partial: [0; 16],
partial_len: 0,
ct_len: 0,
};
h.iter_mut().for_each(|b| *b = 0);
h_key.iter_mut().for_each(|b| *b = 0);
let mut stream = GcmStream {
ctr,
ghash,
tag_mask: Fixed::new([0; 16]),
};
let ctr = &mut stream.ctr;
stream.tag_mask.with_secret_mut(|m| ctr.apply(m));
Some(stream)
}
pub(crate) fn absorb(&mut self, ciphertext: &[u8]) {
self.ghash.update(ciphertext);
}
pub(crate) fn decrypt(&mut self, buf: &mut [u8]) {
self.ghash.update(buf);
self.ctr.apply(buf);
}
pub(crate) fn encrypt(&mut self, buf: &mut [u8]) {
self.ctr.apply(buf);
self.ghash.update(buf);
}
pub(crate) fn tag(self) -> [u8; AES_GCM_TAG_LEN] {
let GcmStream {
ghash, tag_mask, ..
} = self;
let mut tag = ghash.finalize();
tag_mask.with_secret(|m| {
for (t, m) in tag.iter_mut().zip(m) {
*t ^= m;
}
});
tag
}
}
pub(crate) fn gcm_verify<R: Read>(
key: &[u8],
iv: &[u8],
r: &mut R,
ct_len: u64,
) -> io::Result<bool> {
let mut gcm = GcmStream::new(key, iv)
.ok_or_else(|| Fault::Internal("an AES-GCM key length the screen passed").into_io())?;
let mut buf = vec![0u8; CHUNK.min(ct_len as usize).max(AES_GCM_TAG_LEN)];
let mut left = ct_len;
while left > 0 {
let want = (left as usize).min(buf.len());
if read_full(r, &mut buf[..want])? != want {
return Err(io::ErrorKind::UnexpectedEof.into());
}
gcm.absorb(&buf[..want]);
left -= want as u64;
}
let mut want_tag = [0u8; AES_GCM_TAG_LEN];
if read_full(r, &mut want_tag)? != AES_GCM_TAG_LEN {
return Err(io::ErrorKind::UnexpectedEof.into());
}
Ok(ct_eq(&gcm.tag(), &want_tag))
}
pub(crate) struct GcmDecryptReader<R> {
src: R,
gcm: Option<GcmStream>,
left: u64,
}
impl<R: Read> GcmDecryptReader<R> {
pub(crate) fn new(src: R, gcm: GcmStream, ct_len: u64) -> Self {
Self {
src,
gcm: Some(gcm),
left: ct_len,
}
}
}
impl<R: Read> Read for GcmDecryptReader<R> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
if out.is_empty() {
return Ok(0);
}
if self.left == 0 {
let Some(gcm) = self.gcm.take() else {
return Ok(0);
};
let mut want = [0u8; AES_GCM_TAG_LEN];
if read_full(&mut self.src, &mut want)? != AES_GCM_TAG_LEN {
return Err(io::ErrorKind::UnexpectedEof.into());
}
if !ct_eq(&gcm.tag(), &want) {
return Err(Fault::Changed.into_io());
}
return Ok(0);
}
let Some(gcm) = self.gcm.as_mut() else {
return Ok(0);
};
let want = (self.left.min(out.len() as u64)) as usize;
let n = self.src.read(&mut out[..want])?;
if n == 0 {
return Err(io::ErrorKind::UnexpectedEof.into());
}
gcm.decrypt(&mut out[..n]);
self.left -= n as u64;
Ok(n)
}
}
pub(crate) struct GcmEncryptWriter<W: Write> {
dst: W,
gcm: GcmStream,
buf: ChunkBuffer,
}
impl<W: Write> GcmEncryptWriter<W> {
pub(crate) fn new(dst: W, gcm: GcmStream) -> Result<Self, Fault> {
Ok(Self {
dst,
gcm,
buf: chunk_buffer(CHUNK)?,
})
}
pub(crate) fn finish(self) -> io::Result<W> {
let GcmEncryptWriter { mut dst, gcm, .. } = self;
dst.write_all(&gcm.tag())?;
Ok(dst)
}
}
impl<W: Write> Write for GcmEncryptWriter<W> {
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
let n = data.len().min(CHUNK);
let (gcm, dst) = (&mut self.gcm, &mut self.dst);
self.buf.with_secret_mut(|b| {
b[..n].copy_from_slice(&data[..n]);
gcm.encrypt(&mut b[..n]);
dst.write_all(&b[..n])
})?;
Ok(n)
}
fn flush(&mut self) -> io::Result<()> {
self.dst.flush()
}
}
enum CbcDec {
A128(cbc::Decryptor<Aes128>),
A192(cbc::Decryptor<Aes192>),
A256(cbc::Decryptor<Aes256>),
}
impl CbcDec {
fn decrypt_blocks(&mut self, buf: &mut [u8]) -> Result<(), Fault> {
let (blocks, tail) = cbc::cipher::inout::InOutBuf::from(buf).into_chunks();
if !tail.is_empty() {
return Err(Fault::Internal("a CBC span that is not whole blocks"));
}
match self {
CbcDec::A128(d) => d.decrypt_blocks_inout_mut(blocks),
CbcDec::A192(d) => d.decrypt_blocks_inout_mut(blocks),
CbcDec::A256(d) => d.decrypt_blocks_inout_mut(blocks),
}
Ok(())
}
}
pub(crate) struct CbcDecryptReader<R> {
src: R,
dec: CbcDec,
buf: ChunkBuffer,
start: usize,
end: usize,
held: Fixed<[u8; AES_BLOCK_LEN]>,
have_held: bool,
finished: bool,
}
impl<R: Read> CbcDecryptReader<R> {
pub(crate) fn new(src: R, key: &[u8], iv: &[u8]) -> Result<Self, Fault> {
let bad = |_| Fault::Internal("an AES-CBC key or IV length the screen passed");
let dec = match key.len() {
16 => CbcDec::A128(cbc::Decryptor::new_from_slices(key, iv).map_err(bad)?),
24 => CbcDec::A192(cbc::Decryptor::new_from_slices(key, iv).map_err(bad)?),
32 => CbcDec::A256(cbc::Decryptor::new_from_slices(key, iv).map_err(bad)?),
_ => return Err(Fault::Internal("an AES key length the screen passed")),
};
Ok(Self {
src,
dec,
buf: chunk_buffer(CHUNK)?,
start: 0,
end: 0,
held: Fixed::new([0; AES_BLOCK_LEN]),
have_held: false,
finished: false,
})
}
fn refill(&mut self) -> io::Result<bool> {
if self.finished {
return Ok(false);
}
let held = self.have_held;
let prev = &self.held;
let src = &mut self.src;
let dec = &mut self.dec;
let (n, at_end) = self.buf.with_secret_mut(|b| -> io::Result<(usize, bool)> {
let off = if held { AES_BLOCK_LEN } else { 0 };
if held {
prev.with_secret(|p| b[..AES_BLOCK_LEN].copy_from_slice(p));
}
let room = (b.len() - off) / AES_BLOCK_LEN * AES_BLOCK_LEN;
let n = read_full(src, &mut b[off..off + room])?;
if n % AES_BLOCK_LEN != 0 {
return Err(Fault::BadParameters(crate::BadParameter::Member(
crate::MemberFault::NotBlockMultiple,
))
.into_io());
}
dec.decrypt_blocks(&mut b[off..off + n])
.map_err(Fault::into_io)?;
Ok((off + n, n < room))
})?;
if n == 0 {
return Err(Fault::BadParameters(crate::BadParameter::Member(
crate::MemberFault::NotBlockMultiple,
))
.into_io());
}
self.start = 0;
if at_end {
let pad = self.buf.with_secret(|b| b[n - 1]) as usize;
if !(1..=AES_BLOCK_LEN).contains(&pad) || n < pad {
return Err(Fault::WrongPassword.into_io());
}
self.end = n - pad;
self.have_held = false;
self.finished = true;
} else {
self.end = n - AES_BLOCK_LEN;
let held = &mut self.held;
self.buf.with_secret(|b| {
held.with_secret_mut(|h| h.copy_from_slice(&b[n - AES_BLOCK_LEN..n]))
});
self.have_held = true;
}
Ok(true)
}
}
impl<R: Read> Read for CbcDecryptReader<R> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
while self.start == self.end {
if !self.refill()? {
return Ok(0);
}
}
let n = (self.end - self.start).min(out.len());
let start = self.start;
self.buf
.with_secret(|b| out[..n].copy_from_slice(&b[start..start + n]));
self.start += n;
Ok(n)
}
}
pub(crate) struct BlowfishDecryptReader<R> {
src: R,
dec: BufDecryptor<Blowfish>,
}
impl<R: Read> BlowfishDecryptReader<R> {
pub(crate) fn new(src: R, key: &[u8], iv: &[u8]) -> Result<Self, Fault> {
let dec = BufDecryptor::<Blowfish>::new_from_slices(key, iv)
.map_err(|_| Fault::Internal("a Blowfish key or IV length the screen passed"))?;
Ok(Self { src, dec })
}
}
impl<R: Read> Read for BlowfishDecryptReader<R> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
let n = self.src.read(out)?;
self.dec.decrypt(&mut out[..n]);
Ok(n)
}
}
pub(crate) struct ChecksumGate<R> {
src: R,
checksum: Checksum,
window: ChunkBuffer,
pos: usize,
len: usize,
verified: bool,
}
impl<R: Read> ChecksumGate<R> {
pub(crate) fn new(src: R, checksum: Checksum) -> Result<Self, Fault> {
Ok(Self {
src,
checksum,
window: chunk_buffer(CHECKSUM_WINDOW)?,
pos: 0,
len: 0,
verified: false,
})
}
pub(crate) fn verify(&mut self) -> io::Result<()> {
if self.verified {
return Ok(());
}
let src = &mut self.src;
let len = self
.window
.with_secret_mut(|w| read_full(src, &mut w[..]))?;
self.len = len;
let ok = self.window.with_secret(|w| {
let window = &w[..len];
match &self.checksum {
Checksum::Sha1_1K(want) => ct_eq(Sha1::digest(window).as_slice(), want),
Checksum::Sha256_1K(want) => ct_eq(Sha256::digest(window).as_slice(), want),
Checksum::None => true,
}
});
if !ok {
return Err(Fault::WrongPassword.into_io());
}
self.verified = true;
Ok(())
}
}
impl<R: Read> Read for ChecksumGate<R> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
if !self.verified {
self.verify()?;
}
if self.pos < self.len {
let n = (self.len - self.pos).min(out.len());
let pos = self.pos;
self.window
.with_secret(|w| out[..n].copy_from_slice(&w[pos..pos + n]));
self.pos += n;
return Ok(n);
}
self.src.read(out)
}
}
pub(crate) struct InflateReader<R, T = io::Sink> {
src: R,
tap: T,
dec: Box<DecompressorOxide>,
input: ChunkBuffer,
in_start: usize,
in_end: usize,
src_done: bool,
window: ChunkBuffer,
out_pos: usize,
pending: usize,
pending_len: usize,
produced: u64,
expected: u64,
limit: u64,
done: bool,
}
impl<R: Read> InflateReader<R> {
pub(crate) fn new(src: R, expected: u64, limit: u64) -> Result<Self, Fault> {
InflateReader::with_tap(src, expected, limit, io::sink())
}
}
impl<R: Read, T: Write> InflateReader<R, T> {
pub(crate) fn with_tap(src: R, expected: u64, limit: u64, tap: T) -> Result<Self, Fault> {
Ok(Self {
src,
tap,
dec: Box::default(),
input: chunk_buffer(CHUNK)?,
in_start: 0,
in_end: 0,
src_done: false,
window: chunk_buffer(INFLATE_WINDOW)?,
out_pos: 0,
pending: 0,
pending_len: 0,
produced: 0,
expected,
limit,
done: false,
})
}
fn step(&mut self) -> io::Result<()> {
if self.in_start == self.in_end && !self.src_done {
let src = &mut self.src;
let n = self.input.with_secret_mut(|b| read_full(src, &mut b[..]))?;
self.in_start = 0;
self.in_end = n;
self.src_done = n < CHUNK;
}
let flags = if self.src_done {
0
} else {
inflate_flags::TINFL_FLAG_HAS_MORE_INPUT
};
let (in_start, in_end, out_pos) = (self.in_start, self.in_end, self.out_pos);
let dec = &mut self.dec;
let window = &mut self.window;
let (status, consumed, written) = self.input.with_secret(|input| {
window.with_secret_mut(|w| decompress(dec, &input[in_start..in_end], w, out_pos, flags))
});
if consumed > 0 {
let tap = &mut self.tap;
self.input
.with_secret(|input| tap.write_all(&input[in_start..in_start + consumed]))?;
}
self.in_start += consumed;
self.pending = out_pos;
self.pending_len = written;
self.out_pos = (out_pos + written) & (INFLATE_WINDOW - 1);
self.produced += written as u64;
if self.produced > self.limit {
return Err(Fault::OutputLimit.into_io());
}
if self.produced > self.expected {
return Err(
Fault::Inflate(format!("inflates past manifest:size {}", self.expected)).into_io(),
);
}
match status {
TINFLStatus::Done => {
self.done = true;
if self.produced != self.expected {
return Err(Fault::Inflate(format!(
"inflated {} != manifest:size {}",
self.produced, self.expected
))
.into_io());
}
}
TINFLStatus::HasMoreOutput => {}
TINFLStatus::NeedsMoreInput => {
if self.src_done && self.in_start == self.in_end && written == 0 {
return Err(Fault::Inflate("truncated DEFLATE stream".into()).into_io());
}
}
other => return Err(Fault::Inflate(format!("{other:?}")).into_io()),
}
Ok(())
}
}
impl<R: Read, T: Write> Read for InflateReader<R, T> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
while self.pending_len == 0 {
if self.done {
return Ok(0);
}
self.step()?;
}
let n = self.pending_len.min(out.len());
let at = self.pending;
self.window
.with_secret(|w| out[..n].copy_from_slice(&w[at..at + n]));
self.pending += n;
self.pending_len -= n;
Ok(n)
}
}
const STORE_AT_BITS: f64 = 7.5;
const STORED_BLOCK_MAX: usize = 0xFFFF;
pub(crate) struct DeflateWriter<W: Write> {
dst: W,
comp: Box<CompressorOxide>,
out: ChunkBuffer,
consumed: u64,
held: Option<Held>,
}
struct Held {
buf: ChunkBuffer,
len: usize,
compressing: bool,
}
impl<W: Write> DeflateWriter<W> {
pub(crate) fn new(dst: W) -> Result<Self, Fault> {
let flags = create_comp_flags_from_zip_params(6, 0, 0);
Ok(Self {
dst,
comp: Box::new(CompressorOxide::new(flags)),
out: chunk_buffer(CHUNK)?,
consumed: 0,
held: None,
})
}
pub(crate) fn adaptive(dst: W) -> Result<Self, Fault> {
let mut w = Self::new(dst)?;
w.held = Some(Held {
buf: chunk_buffer(CHUNK)?,
len: 0,
compressing: false,
});
Ok(w)
}
fn release(&mut self, held: &mut Held) -> io::Result<()> {
let len = held.len;
if len == 0 {
return Ok(());
}
held.len = 0;
let incompressible = held.buf.with_secret(|b| entropy_bits(&b[..len])) >= STORE_AT_BITS;
if !incompressible {
held.compressing = true;
return held
.buf
.with_secret(|b| self.pump(&b[..len], TDEFLFlush::None));
}
if held.compressing {
self.pump(&[], TDEFLFlush::Full)?;
held.compressing = false;
}
let dst = &mut self.dst;
held.buf.with_secret(|b| -> io::Result<()> {
for block in b[..len].chunks(STORED_BLOCK_MAX) {
let n = block.len() as u16;
let [lo, hi] = n.to_le_bytes();
let [nlo, nhi] = (!n).to_le_bytes();
dst.write_all(&[0, lo, hi, nlo, nhi])?;
dst.write_all(block)?;
}
Ok(())
})?;
Ok(())
}
pub(crate) fn consumed(&self) -> u64 {
self.consumed
}
fn pump(&mut self, mut input: &[u8], flush: TDEFLFlush) -> io::Result<()> {
loop {
let comp = &mut self.comp;
let (status, used, made) = self
.out
.with_secret_mut(|o| compress(comp, input, &mut o[..], flush));
input = &input[used..];
let dst = &mut self.dst;
self.out.with_secret(|o| dst.write_all(&o[..made]))?;
match status {
TDEFLStatus::Done => return Ok(()),
TDEFLStatus::Okay => {
let finishing = matches!(flush, TDEFLFlush::Finish);
if input.is_empty() && made < CHUNK && !finishing {
return Ok(());
}
if used == 0 && made == 0 && !finishing {
return Err(Fault::Deflate("no progress".into()).into_io());
}
}
other => {
return Err(Fault::Deflate(format!("{other:?}")).into_io());
}
}
}
}
pub(crate) fn finish(mut self) -> io::Result<W> {
if let Some(mut held) = self.held.take() {
self.release(&mut held)?;
}
self.pump(&[], TDEFLFlush::Finish)?;
Ok(self.dst)
}
}
fn entropy_bits(bytes: &[u8]) -> f64 {
let mut counts = [0u32; 256];
for &b in bytes {
counts[b as usize] += 1;
}
let n = bytes.len() as f64;
let bits = counts
.iter()
.filter(|&&c| c > 0)
.map(|&c| {
let p = f64::from(c) / n;
-p * p.log2()
})
.sum();
counts.iter_mut().for_each(|c| *c = 0);
bits
}
impl<W: Write> Write for DeflateWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.consumed += buf.len() as u64;
let Some(mut held) = self.held.take() else {
self.pump(buf, TDEFLFlush::None)?;
return Ok(buf.len());
};
let mut rest = buf;
let result = loop {
let at = held.len;
let take = (CHUNK - at).min(rest.len());
held.buf
.with_secret_mut(|b| b[at..at + take].copy_from_slice(&rest[..take]));
held.len += take;
rest = &rest[take..];
if held.len < CHUNK {
break Ok(buf.len());
}
if let Err(e) = self.release(&mut held) {
break Err(e);
}
};
self.held = Some(held);
result
}
fn flush(&mut self) -> io::Result<()> {
self.dst.flush()
}
}
#[cfg(test)]
#[path = "stream_tests.rs"]
mod tests;