unarc-rs

A Rust library for reading and extracting various archive formats, with a focus on legacy/retro formats from the BBS era, plus modern formats like 7z.

Supported Formats

Archive Formats

Single-File Compression

Compressed Archives

Note: Single-file formats (.Z, .gz, .bz2) compress one file only. When a path like file.tar.gz is opened, the library detects it as a compressed TAR archive, returning all entries from the inner TAR.

Installation

Add to your Cargo.toml:

[dependencies]
unarc-rs = "0.5"

Quick Start

Using the Unified API (Recommended)

use unarc_rs::unified::ArchiveFormat;

// Open archive directly from path
let mut archive = ArchiveFormat::open_path("archive.arj")?;

// Iterate over entries
for entry in archive.entries_iter() {
    let entry = entry?;
    println!("{}: {} bytes", entry.name(), entry.original_size());
}

Extracting Files

use std::fs::File;
use unarc_rs::unified::ArchiveFormat;

let mut archive = ArchiveFormat::open_path("archive.zip")?;

while let Some(entry) = archive.next_entry()? {
    // Extract to a file
    let mut output = File::create(entry.file_name())?;
    archive.read_to(&entry, &mut output)?;
}

Using a Specific Format

use std::fs::File;
use unarc_rs::unified::ArchiveFormat;

let file = File::open("data.arj")?;
let mut archive = ArchiveFormat::Arj.open(file)?;

for entry in archive.entries_iter() {
    let entry = entry?;
    let data = archive.read(&entry)?;
    // ... process data
}

Format Detection

use std::path::Path;
use unarc_rs::unified::{ArchiveFormat, is_supported_archive};

// Check if a file is a supported archive
if is_supported_archive(Path::new("file.arj")) {
    println!("Supported!");
}

// Get format from path
if let Some(format) = ArchiveFormat::from_path(Path::new("archive.zoo")) {
    println!("Format: {}", format.name()); // "ZOO"
}

API Overview

ArchiveFormat

• open_path(path) - Open archive from file path (auto-detects format)
• open(reader) - Open archive from any Read + Seek
• open_multi_volume_zip(paths, options) - Open multi-volume ZIP archive
• open_multi_volume_7z(paths, options) - Open multi-volume 7z archive
• from_path(path) - Detect format from path
• name() / extension() / extensions() - Format metadata

UnifiedArchive

• next_entry() - Get next entry (returns Option<ArchiveEntry>)
• entries_iter() - Iterator over all entries
• read(&entry) - Read entry data into Vec<u8>
• read_to(&entry, &mut writer) - Stream entry data to writer
• skip(&entry) - Skip entry without reading

ArchiveEntry

• name() / file_name() - Entry name (with/without path)
• original_size() / compressed_size() - Sizes
• compression_method() - Compression algorithm used
• compression_ratio() - Compression efficiency
• modified_time() - Modification timestamp
• crc() - Checksum
• encryption() - Encryption method used
• is_encrypted() - Whether the entry is encrypted

Encryption Support

Several formats support encrypted archives:

To decrypt, use ArchiveOptions with a password:

use unarc_rs::unified::{ArchiveFormat, ArchiveOptions};

let mut archive = ArchiveFormat::open_path("encrypted.arj")?;
let options = ArchiveOptions::new().with_password("secret");

while let Some(entry) = archive.next_entry()? {
    let data = archive.read_with_options(&entry, &options)?;
    // ... process decrypted data
}

Format-Specific Notes

7z

Full support via the sevenz-rust2 crate. Supports LZMA, LZMA2, and other 7z compression methods. AES-256 encrypted archives are supported (password required).

Multi-volume support: Split 7z archives (.7z.001, .7z.002, etc.) are supported via open_multi_volume_7z().

ZIP

Full support via the zip crate with legacy compression methods enabled.

Multi-volume support: Split ZIP archives (.zip.001, .z01/.z02/.zip, etc.) are supported via open_multi_volume_zip().

RAR

Full support for RAR4 and RAR5 via the unrar crate (uses native unrar library).

LHA/LZH

Full support via the excellent delharc crate.

ACE

ACE archive support with LZ77+Huffman decompression. Supports both ACE 1.0 (LZ77 mode) and ACE 2.0 (Blocked mode). Blowfish encryption is supported (password required). Multi-volume archives are not supported.

https://github.com/droe/acefile

ARC

Classic DOS archiver. Crushed & Distilled methods are not supported.

ARC/PAK can be password-decrypted (simple XOR), but the format has no reliable encryption flag in headers.

ARJ

Popular in the BBS scene in the 90s. Supports Garble and GOST40 encryption (password required). GOST-256 (ARJCRYPT) is detected but not supported. Multi-volume archives are not supported.

UC2

UltraCompressor II archive format. Supports decompression with SuperMaster dictionary and custom master entries.

UltraCrypt (UE2) encrypted wrappers are detected but not supported.

ZOO

Classic DOS/Amiga archiver from 1986. Native implementation supporting all compression methods.

HA

Harri Hirvola's archiver (1993). Native implementation with ASC (arithmetic coding) and HSC (static Huffman) support.

SQ/SQ2

CP/M and DOS "squeeze" format. Huffman-based compression used for single files, commonly seen as ?Q? patterns (e.g., .BQK for .BAS).

TAR Variants

TAR archives can be wrapped with compression. The library auto-detects .tar.gz, .tar.bz2, and .tar.Z from the file path and handles decompression transparently.

Background

This library was written for my icy_board BBS project. It focuses on extraction (not creation) of legacy archive formats.

Contributions welcome! Contact me on the icy_board repo or via email if I miss issues/PRs here.

Related projects

https://github.com/temisu/ancient

License

MIT OR Apache-2.0