Struct Encryptor 

pub struct Encryptor<W> { /* private fields */ }

A Write adapter that encrypts a ZipCrypto entry on the fly.

On construction it emits the 12-byte encryption header; writes then encrypt the (already compressed) body.

The encryption header includes a single check byte for a cheap reader-side password test. rawzip always emits a data descriptor, so it is the high byte of the entry’s DOS mod time (see Encryptor::new).

Examples

let password = b"rawzipiscool";
let mut output = std::io::Cursor::new(Vec::new());
let mut archive = ZipArchiveWriter::new(&mut output);

let (mut entry, config) = archive
    .new_file("test.txt")
    .compression_method(CompressionMethod::DEFLATE)
    .encrypted(true)
    .start()?;

// In production these 11 bytes must come from a cryptographic RNG.
let header_random = [0u8; 11];
// rawzip always writes a data descriptor, so the check byte is the high
// byte of the DOS mod time.
let check_byte = (entry.last_modified_dos().packed_time() >> 8) as u8;
let encryptor = Encryptor::new(&mut entry, password, header_random, check_byte)?;

let deflater = flate2::write::DeflateEncoder::new(encryptor, flate2::Compression::default());
let mut writer = config.wrap(deflater);
writer.write_all(b"aaaaaaaaaaaaaaaa\n")?;
let (deflater, descriptor) = writer.finish()?;
deflater.finish()?; // drops the encryptor, releasing the borrow on `entry`
entry.finish(descriptor)?;
archive.finish()?;

// Round-trips back through the reader.
let zip = output.into_inner();
let archive = ZipArchive::from_slice(&zip)?;
let entry = archive.entries().next().unwrap()?;
let zip_entry = archive.get_entry(entry.wayfinder())?;
let decryptor = Decryptor::new(zip_entry.data(), password)?;
let inflater = flate2::read::DeflateDecoder::new(decryptor);
let mut decoded = Vec::new();
zip_entry.verifying_reader(inflater).read_to_end(&mut decoded)?;
assert_eq!(decoded, b"aaaaaaaaaaaaaaaa\n");

Implementations

impl<W: Write> Encryptor<W>

pub fn new( writer: W, password: &[u8], header_random: [u8; 11], check_byte: u8, ) -> Result<Self>

Wraps a writer positioned at the start of an entry’s body, emitting the encrypted 12-byte encryption header.

header_random are the 11 leading header bytes. They are security-only: any values produce a valid, round-trippable archive, but reusing them across entries under the same password leaks information, so draw them from a cryptographic RNG in production.

check_byte is the 1-in-256 password verifier the reader checks: the high byte of the entry’s CRC32, or of its DOS mod time when the entry carries a data descriptor (general purpose bit 3). rawzip’s writer always sets that bit, so for its entries compute it as (entry.last_modified_dos().packed_time() >> 8) as u8.

pub fn into_inner(self) -> W

Consumes the encryptor, returning the wrapped writer.

pub fn get_ref(&self) -> &W

Gets a shared reference to the underlying writer.

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

Gets a mutable reference to the underlying writer.

Writing directly to it bypasses encryption, so use with care.

Trait Implementations

impl<W: Debug> Debug for Encryptor<W>

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

Formats the value using the given formatter.

impl<W: Write> Write for Encryptor<W>

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

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

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

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

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

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

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.

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

Attempts to write an entire buffer into this writer.

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.

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

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

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

where Self: Sized,

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