zip Rust Library

Fuzzing is supported via cargo afl. To begin, install the tool and then follow the specific build commands for reading or writing.

Install cargo-afl:

cargo install cargo-afl

Fuzzing Extraction (Reading):

1. Create an output directory: mkdir -vp fuzz-read-out
2. Build the fuzzer: cargo afl build --manifest-path=fuzz/Cargo.toml --all-features -p fuzz_read
3. Run with a curated corpus: cargo afl fuzz -i fuzz/read/in -o fuzz-read-out fuzz/target/debug/fuzz_read
4. Run with test data: cargo afl fuzz -i tests/data -e zip -o fuzz-read-out fuzz/target/debug/fuzz_read

Fuzzing Creation (Writing):

1. Create an output directory: mkdir -vp fuzz-write-out
2. Build the fuzzer: cargo afl build --manifest-path=fuzz/Cargo.toml --all-features -p fuzz_write
3. Run with corpus and dictionary: cargo afl fuzz -x fuzz/write/fuzz.dict -i fuzz/write/in -o fuzz-write-out fuzz/target/debug/fuzz_write

# Example: Install cargo-afl
cargo install cargo-afl

The CompressionMethod enum identifies the storage format used to compress a file within a ZIP archive. When creating ZIP files, you can specify the method using crate::write::FileOptions::compression_method.

Note that availability of certain methods depends on enabled Cargo features (e.g., deflate64, bzip2, zstd, lzma, xz, ppmd, aes-crypto).

Common methods include:

• Stored: No compression applied.
• Deflated: Standard Deflate compression (requires _deflate-any).
• Deflate64: Deflate64 compression (requires deflate64).
• Bzip2: BZIP2 compression (requires _bzip2_any).
• Zstd: ZStandard compression (requires zstd).
• Lzma: LZMA compression (requires lzma).
• Xz: XZ compression (requires xz).
• Ppmd: PPMd compression (requires ppmd).
• Aes: AES encryption (requires aes-crypto).
• Legacy methods: Shrink, Reduce, and Implode (requires legacy-zip).

use zip::CompressionMethod;

// Example: Using a compression method in FileOptions (contextual)
// let options = FileOptions::default().compression_method(CompressionMethod::Deflated);

To encrypt data using AES, use AesWriter. This writer handles the generation of a random salt, derivation of keys via PBKDF2, and the appending of the HMAC authentication code.

1. Initialize the writer with AesWriter::new_with_options(writer, aes_mode, password, custom_salt). Pass None for custom_salt to use a randomly generated one.
2. Write your plaintext data using the Write trait implementation.
3. Crucially, call .finish() to write the encrypted file header and the final 10-byte authentication code. If you do not call finish(), the archive will be invalid.

Warning: AesWriter uses an internal buffer to ensure proper encryption and zeroizes memory to prevent cleartext leakage.

use std::io::Write;
// Assuming AesWriter and AesMode are available in scope
let mut writer = AesWriter::new_with_options(&mut output_writer, AesMode::Aes256, password, None)?;
writer.write_all(plaintext_data)?;
writer.finish()?; // Must call finish to append HMAC and header

To decrypt a file encrypted with AES, use AesReader to read the header and validate the password. The validate method performs an initial password check using PBKDF2. Note that a full integrity check (HMAC) is only performed after the entire file has been read via the resulting AesReaderValid instance.

1. Create an AesReader using AesReader::new(reader, aes_mode, compressed_size).
2. Call .validate(password) to get an AesReaderValid instance.
3. Read the data from the AesReaderValid instance. If the password was incorrect or the data was tampered with, the final read call (when data_remaining reaches 0) will return an io::Error with ErrorKind::InvalidData.

Note: There is a 1 in 65,536 chance that an incorrect password passes the initial validate check; the HMAC check in AesReaderValid is the definitive verification.

use std::io::Read;
// Assuming AesReader and AesMode are available in scope
let mut reader = AesReader::new(&mut input_reader, AesMode::Aes256, compressed_size);
let mut valid_reader = reader.validate(password_bytes)?;
let mut decrypted_data = Vec::new();
valid_reader.read_to_end(&mut decrypted_data)?;

You can enable or disable specific compression algorithms and features using Cargo features. By default, the following are enabled: aes-crypto, bzip2, deflate, deflate64, lzma, ppmd, time, xz, and zstd.