Struct Decryptor 

pub struct Decryptor<R> { /* private fields */ }

A Read adapter that decrypts a ZipCrypto entry on the fly.

On construction it consumes the 12-byte encryption header; reads then yield the decrypted (but still compressed) body, so wrap it in a decompressor to recover the original data.

ZipCrypto’s single check byte is weak verification, so still validate the output against the entry’s CRC32 (e.g. via ZipSliceEntry::verifying_reader).

Examples

let data = std::fs::read("assets/zipcrypto.zip")?;
let archive = ZipArchive::from_slice(&data)?;
let entry = archive.entries().next().unwrap()?;
let zip_entry = archive.get_entry(entry.wayfinder())?;

let decryptor = Decryptor::new(zip_entry.data(), b"rawzipiscool")?;

// Optionally, for a cheap up-front password check, use `check_byte`. Omitted from
// the example for brevity.

let inflater = flate2::read::DeflateDecoder::new(decryptor);

// The verifying reader checks the decrypted data against the entry's CRC32.
let mut output = Vec::new();
zip_entry.verifying_reader(inflater).read_to_end(&mut output)?;
assert_eq!(output, b"aaaaaaaaaaaaaaaa\n");

Implementations

impl<R: Read> Decryptor<R>

pub fn new(reader: R, password: &[u8]) -> Result<Self>

Wraps a reader positioned at the start of an entry’s encrypted data, reading and decrypting the encryption header.

Check check_byte afterwards for a cheap password sanity test.

pub fn check_byte(&self) -> u8

The final byte of the decrypted header, a 1-in-256 password check.

Equals the high byte of the entry’s CRC32, or of its DOS mod time when the entry carries a data descriptor

pub fn into_inner(self) -> R

Consumes the reader, returning the wrapped reader.

Trait Implementations

impl<R: Debug> Debug for Decryptor<R>

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

Formats the value using the given formatter.

impl<R: Read> Read for Decryptor<R>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

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

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

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

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

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

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

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

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

Read and return a type (e.g. an integer) in big-endian order.