### Install payload-dumper-rust via CLI

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Quick installation scripts for Unix-based systems and Windows, or building directly from source using Cargo.

```bash
bash <(curl -sSL "https://raw.githubusercontent.com/rhythmcache/payload-dumper-rust/main/scripts/install.sh")
```

```powershell
powershell -NoExit -ExecutionPolicy Bypass -Command "Invoke-RestMethod -Uri 'https://raw.githubusercontent.com/rhythmcache/payload-dumper-rust/main/scripts/install.ps1' | Invoke-Expression"
```

```bash
cargo install payload_dumper
```

--------------------------------

### Create Local ZIP Payload Reader and Extract Boot Partition (Rust)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

This example demonstrates creating a `LocalAsyncZipPayloadReader` to read from a `payload.bin` file within a local ZIP archive. It parses the manifest from the ZIP and extracts the 'boot' partition. Dependencies include `tokio`, `anyhow`, and the `payload_dumper` crate.

```rust
use payload_dumper::readers::local_zip_reader::LocalAsyncZipPayloadReader;
use payload_dumper::payload::payload_dumper::{NoOpReporter, dump_partition};
use payload_dumper::payload::payload_parser::parse_local_zip_payload;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let zip_path = PathBuf::from("rom.zip");

    // Create ZIP payload reader
    let reader = LocalAsyncZipPayloadReader::new(zip_path.clone()).await?;

    // Parse manifest from ZIP
    let (manifest, data_offset) = parse_local_zip_payload(zip_path).await?;
    let block_size = manifest.block_size.unwrap_or(4096) as u64;

    // Extract boot partition from ZIP
    if let Some(partition) = manifest.partitions.iter().find(|p| p.partition_name == "boot") {
        let output_path = PathBuf::from("output/boot.img");

        dump_partition(
            partition,
            data_offset,
            block_size,
            output_path,
            &reader,
            &NoOpReporter,
            None,
        ).await?;

        println!("Extracted boot.img from ZIP");
    }

    Ok(())
}
```

--------------------------------

### Extract Android OTA Partitions

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Basic usage examples for extracting images from local files, ROM ZIPs, and remote URLs. Supports filtering specific partitions and listing contents.

```bash
payload_dumper payload.bin -o output
payload_dumper rom.zip -o output
payload_dumper https://example.com/ota.zip -o output
payload_dumper payload.bin -i boot,vendor_boot -o output
payload_dumper payload.bin --list
```

--------------------------------

### Build from Source

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Steps to clone the repository and compile the project using Cargo for a release build.

```bash
git clone --depth 1 https://github.com/rhythmcache/payload-dumper-rust.git
cd payload-dumper-rust
cargo build --release
```

--------------------------------

### Create Local Payload Reader and Extract Partitions (Rust)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

This snippet shows how to create a `LocalAsyncPayloadReader` to read from a local `payload.bin` file. It then parses the manifest and extracts all partitions into individual image files. Dependencies include `tokio`, `anyhow`, and the `payload_dumper` crate.

```rust
use payload_dumper::readers::local_reader::LocalAsyncPayloadReader;
use payload_dumper::payload::payload_dumper::{AsyncPayloadRead, NoOpReporter, dump_partition};
use payload_dumper::payload::payload_parser::parse_local_payload;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let payload_path = PathBuf::from("payload.bin");

    // Create local payload reader
    let reader = LocalAsyncPayloadReader::new(payload_path.clone()).await?;

    // Parse manifest
    let (manifest, data_offset) = parse_local_payload(&payload_path).await?;
    let block_size = manifest.block_size.unwrap_or(4096) as u64;

    // Extract all partitions
    for partition in &manifest.partitions {
        let output_path = PathBuf::from(format!("output/{}.img", partition.partition_name));

        dump_partition(
            partition,
            data_offset,
            block_size,
            output_path,
            &reader,
            &NoOpReporter,
            None,
        ).await?;

        println!("Extracted: {}", partition.partition_name);
    }

    Ok(())
}
```

--------------------------------

### List Available Partitions (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface to display all partitions present in the payload file without actually extracting them. This is useful for inspecting the contents of a payload.

```bash
payload_dumper payload.bin --list
```

--------------------------------

### Extract Partitions from ROM ZIP (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface for extracting partitions directly from a ROM ZIP file without needing to unzip it first. Allows extraction of all partitions or specific ones.

```bash
# Extract all partitions from ZIP
payload_dumper rom.zip -o output

# Extract specific partitions from ZIP
payload_dumper rom.zip -i boot,vendor_boot -o output
```

--------------------------------

### Extract Incremental OTA (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface for extracting partitions from an incremental OTA update. Requires providing source images from the previous build, either in a default 'old' directory or a custom source directory.

```bash
# Using default "old" directory in current working directory
mkdir old
cp /path/to/previous/build/*.img old/
payload_dumper incremental_ota.zip -o output

# Using custom source directory
payload_dumper incremental_ota.zip --source-dir /path/to/old/images -o output
```

--------------------------------

### Extract Partitions from Remote URL (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface for extracting partitions from a remote URL. It downloads only the necessary data, supporting options like prefetch mode, custom User-Agent, cookies, and custom DNS servers.

```bash
# Basic URL extraction
payload_dumper https://example.com/ota.zip -o output

# URL extraction with prefetch mode (better for slow connections)
payload_dumper https://example.com/ota.zip --prefetch -o output

# URL extraction with custom User-Agent
payload_dumper https://example.com/ota.zip -U "Mozilla/5.0" -o output

# URL extraction with cookies for authenticated requests
payload_dumper https://example.com/ota.zip -C "session=abc123" -o output

# URL extraction with custom DNS servers
payload_dumper https://example.com/ota.zip --dns 8.8.8.8,8.8.4.4 -o output
```

--------------------------------

### Create Remote ZIP Payload Reader and Extract Partition (Rust)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

This snippet illustrates using `RemoteAsyncZipPayloadReader` to read from a remote ZIP file via HTTP range requests, avoiding a full download. It parses the remote manifest and extracts a specific partition. Dependencies include `tokio`, `anyhow`, and the `payload_dumper` crate. It allows for custom user agents and other HTTP configurations.

```rust
use payload_dumper::readers::remote_zip_reader::RemoteAsyncZipPayloadReader;
use payload_dumper::payload::payload_dumper::{NoOpReporter, dump_partition};
use payload_dumper::payload::payload_parser::parse_remote_payload;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = "https://example.com/ota.zip".to_string();

    // Create remote ZIP reader with optional HTTP configuration
    let reader = RemoteAsyncZipPayloadReader::new(
        url.clone(),
        Some("CustomUserAgent/1.0"),
        None,  // cookies
        None,  // custom DNS
    ).await?;

    // Parse remote payload
    let (manifest, data_offset, _content_length) = parse_remote_payload(
        url,
        Some("CustomUserAgent/1.0"),
        None,
        None,
    ).await?;

    let block_size = manifest.block_size.unwrap_or(4096) as u64;

    // Extract specific partition from remote URL
    if let Some(partition) = manifest.partitions.iter().find(|p| p.partition_name == "boot") {
        let output_path = PathBuf::from("output/boot.img");

        dump_partition(
            partition,
            data_offset,
            block_size,
            output_path,
            &reader,
            &NoOpReporter,
            None,
        ).await?;

        println!("Extracted boot.img from remote URL");
    }

    Ok(())
}
```

--------------------------------

### Prefetch and Dump Partition in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Provides a robust method for downloading and extracting specific partitions from a remote payload. It uses a temporary file buffer to handle high-latency connections and supports custom progress reporting.

```rust
use payload_dumper::prefetch::{prefetch_and_dump_partition, PartitionExtractionConfig, ExtractionPaths, DownloadProgressReporter};
use payload_dumper::http::HttpReader;
use std::path::PathBuf;

// Implementation of DownloadProgressReporter omitted for brevity

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let http_reader = HttpReader::new("https://example.com/ota.zip".to_string(), None, None, None).await?;
    let config = PartitionExtractionConfig { data_offset: 0, block_size: 4096, payload_offset: 0 };
    let paths = ExtractionPaths { temp_path: PathBuf::from("/tmp/boot.tmp"), output_path: PathBuf::from("boot.img") };

    // Assuming 'partition' is retrieved from manifest
    // prefetch_and_dump_partition(partition, &config, &http_reader, paths, &reporter, &no_op, None).await?;
    Ok(())
}
```

--------------------------------

### Extract Partitions from Local payload.bin (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface for extracting all or specific partitions from a local payload.bin file. Supports options for thread count, hash verification, and sequential extraction.

```bash
# Basic extraction
payload_dumper payload.bin -o output

# Extract with custom thread count
payload_dumper payload.bin -t 8 -o output

# Extract without hash verification (faster but less safe)
payload_dumper payload.bin --no-verify -o output

# Sequential extraction (lower memory usage)
payload_dumper payload.bin --no-parallel -o output
```

--------------------------------

### Build Static Binary with Built-in DNS (Rust)

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Builds a fully static binary for the payload dumper, ensuring DNS resolution works without system libc dependencies. This is achieved by enabling the 'hickory_dns' feature, which uses a built-in DNS resolver, defaulting to Cloudflare DNS.

```bash
cargo build --release --features hickory_dns
```

--------------------------------

### Export Metadata as JSON (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface to export payload metadata to a JSON file. Supports exporting compact metadata (essential info) or full metadata including operation details.

```bash
# Compact metadata (essential info only)
payload_dumper payload.bin --metadata -o output
# Creates output/payload_metadata.json

# Full metadata with operation details
payload_dumper payload.bin --metadata=full -o output
```

--------------------------------

### Extract Specific Partitions (CLI)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Command-line interface to extract only selected partitions by name using a comma-separated list. This is useful when only specific images are needed.

```bash
# Extract boot and vendor_boot partitions
payload_dumper payload.bin -i boot,vendor_boot -o output

# Extract system and vendor partitions
payload_dumper payload.bin -i system,vendor -o output
```

--------------------------------

### Enable Remote HTTP/HTTPS Support (Rust)

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Builds the payload dumper with support for remote URLs via HTTP/HTTPS. This requires enabling the 'remote_zip' feature.

```bash
cargo build --release --features remote_zip
```

--------------------------------

### Override DNS Server at Runtime (Bash)

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Demonstrates how to override the default DNS server for the payload dumper at runtime. This can be done using either an environment variable or a command-line flag. The CLI flag takes precedence if both are provided.

```bash
export PAYLOAD_DUMPER_CUSTOM_DNS=8.8.8.8,4.4.4.4
./payload_dumper <PAYLOAD>
```

```bash
./payload_dumper --dns 8.8.8.8,4.4.4.4 <PAYLOAD>
```

--------------------------------

### Detect File Type and Format Size/Time in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Demonstrates using utility functions to detect file types based on magic bytes and format byte sizes and elapsed durations into human-readable strings. Requires the 'payload_dumper' crate.

```rust
use payload_dumper::utils::{detect_file, format_size, format_elapsed_time, FileType};
use std::time::Duration;

fn main() -> anyhow::Result<()> {
    // Detect file type from magic bytes
    let zip_magic: [u8; 4] = [0x50, 0x4B, 0x03, 0x04];  // "PK.."
    let payload_magic: [u8; 4] = [0x43, 0x72, 0x41, 0x55];  // "CrAU"

    match detect_file(&zip_magic)? {
        FileType::Zip => println!("Detected ZIP file"),
        FileType::Bin => println!("Detected payload.bin file"),
    }

    match detect_file(&payload_magic)? {
        FileType::Zip => println!("Detected ZIP file"),
        FileType::Bin => println!("Detected payload.bin file"),
    }

    // Format file sizes
    println!("{}", format_size(1024));           // "1.00 KB"
    println!("{}", format_size(1048576));        // "1.00 MB"
    println!("{}", format_size(1073741824));     // "1.00 GB"
    println!("{}", format_size(3221225472));     // "3.00 GB"

    // Format elapsed time
    println!("{}", format_elapsed_time(Duration::from_secs(5)));      // "5.000s"
    println!("{}", format_elapsed_time(Duration::from_secs(125)));    // "2m 5.000s"
    println!("{}", format_elapsed_time(Duration::from_secs(3725)));   // "1h 2m 5.000s"

    Ok(())
}

```

--------------------------------

### Advanced Extraction Options

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Advanced configuration including thread management, metadata exportation, and skipping verification for faster processing.

```bash
payload_dumper https://example.com/ota.zip --prefetch -o output
payload_dumper payload.bin -t 8 -o output
payload_dumper payload.bin --metadata -o output
payload_dumper payload.bin --no-verify -o output
```

--------------------------------

### Build for Local Files Only (Rust)

Source: https://github.com/rhythmcache/payload-dumper-rust/blob/main/README.md

Builds the payload dumper with only local file support, disabling network features. This results in faster compilation and a smaller binary size by removing HTTP, DNS, and TLS dependencies.

```bash
cargo build --release --no-default-features
```

--------------------------------

### Extract Payload Metadata in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Demonstrates how to parse a local Android OTA payload file and extract its metadata into a structured, JSON-serializable format. This is useful for inspecting partition details, compression types, and security patch levels.

```rust
use payload_dumper::metadata::get_metadata;
use payload_dumper::payload::payload_parser::parse_local_payload;
use std::path::Path;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let payload_path = Path::new("payload.bin");
    let (manifest, data_offset) = parse_local_payload(payload_path).await?;
    let metadata = get_metadata(&manifest, data_offset, false, None).await?;

    println!("Block size: {}", metadata.block_size);
    let json = serde_json::to_string_pretty(&metadata)?;
    std::fs::write("payload_metadata.json", json)?;
    Ok(())
}
```

--------------------------------

### Parse Local Payload (Rust Library API)

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Rust library function to parse an Android OTA payload.bin file from the local filesystem. It returns the payload manifest and the data offset, allowing programmatic access to payload information.

```rust
use payload_dumper::payload::payload_parser::parse_local_payload;
use std::path::Path;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let payload_path = Path::new("payload.bin");

    // Parse the payload file
    let (manifest, data_offset) = parse_local_payload(payload_path).await?;

    // Access manifest information
    println!("Block size: {}", manifest.block_size.unwrap_or(4096));
    println!("Number of partitions: {}", manifest.partitions.len());

    if let Some(security_patch) = &manifest.security_patch_level {
        println!("Security patch level: {}", security_patch);
    }

    // List all partition names and sizes
    for partition in &manifest.partitions {
        if let Some(info) = &partition.new_partition_info {
            let size = info.size.unwrap_or(0);
            println!("  {} - {} bytes", partition.partition_name, size);
        }
    }

    println!("Data offset: {}", data_offset);
    Ok(())
}
```

--------------------------------

### Read Remote Files with HttpReader in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Implements a low-level HTTP client capable of performing range requests. This allows for reading specific chunks of a remote file without downloading the entire payload, which is essential for efficient parsing.

```rust
use payload_dumper::http::HttpReader;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = "https://example.com/payload.bin".to_string();
    let reader = HttpReader::new(url, Some("CustomUserAgent/1.0"), None, None).await?;

    let mut buffer = vec![0u8; 1024];
    reader.read_at(0, &mut buffer).await?;

    if &buffer[0..4] == b"CrAU" {
        println!("Valid Android OTA payload detected");
    }
    Ok(())
}
```

--------------------------------

### Dump Partition with Progress Reporting in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Extracts a single partition from a payload to disk with progress reporting and optional hash verification. It defines a custom `ConsoleReporter` and uses `dump_partition` to extract data.

```rust
use payload_dumper::payload::payload_dumper::{dump_partition, ProgressReporter, NoOpReporter};
use payload_dumper::payload::payload_parser::parse_local_payload;
use payload_dumper::readers::local_reader::LocalAsyncPayloadReader;
use std::path::{Path, PathBuf};

// Custom progress reporter implementation
struct ConsoleReporter;

impl ProgressReporter for ConsoleReporter {
    fn on_start(&self, partition_name: &str, total_operations: u64) {
        println!("Starting extraction of {} ({} operations)", partition_name, total_operations);
    }

    fn on_progress(&self, partition_name: &str, current_op: u64, total_ops: u64) {
        let percent = (current_op as f64 / total_ops as f64) * 100.0;
        print!("\r{}: {{:.1}}% ({{}}/{{}})", partition_name, percent, current_op, total_ops);
    }

    fn on_complete(&self, partition_name: &str, total_operations: u64) {
        println!("\n{} extraction complete ({} operations)", partition_name, total_operations);
    }

    fn on_warning(&self, partition_name: &str, operation_index: usize, message: String) {
        eprintln!("Warning in {} op {{}}: {{}}", partition_name, operation_index, message);
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let payload_path = Path::new("payload.bin");
    let output_dir = PathBuf::from("output");

    // Parse the payload
    let (manifest, data_offset) = parse_local_payload(payload_path).await?;
    let block_size = manifest.block_size.unwrap_or(4096) as u64;

    // Create payload reader
    let reader = LocalAsyncPayloadReader::new(payload_path.to_path_buf()).await?;
    let reporter = ConsoleReporter;

    // Find and extract the boot partition
    for partition in &manifest.partitions {
        if partition.partition_name == "boot" {
            let output_path = output_dir.join(format!("{}.img", partition.partition_name));

            dump_partition(
                partition,
                data_offset,
                block_size,
                output_path,
                &reader,
                &reporter,
                None,  // source_dir for incremental OTA
            ).await?;

            break;
        }
    }

    Ok(())
}
```

--------------------------------

### Parse Local ZIP Payload in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Parses a `payload.bin` file from a local ZIP archive without extracting the entire archive. It uses the `parse_local_zip_payload` function and returns the manifest and data offset.

```rust
use payload_dumper::payload::payload_parser::parse_local_zip_payload;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let zip_path = PathBuf::from("rom.zip");

    // Parse payload.bin from inside the ZIP file
    let (manifest, data_offset) = parse_local_zip_payload(zip_path).await?;

    println!("Found {} partitions in ZIP:", manifest.partitions.len());
    for partition in &manifest.partitions {
        println!("  - {}", partition.partition_name);
    }

    Ok(())
}
```

--------------------------------

### Parse Remote ZIP Payload in Rust

Source: https://context7.com/rhythmcache/payload-dumper-rust/llms.txt

Parses a payload from a remote ZIP URL using HTTP range requests, downloading only the metadata. It supports custom User-Agents, cookies, and DNS configurations via `parse_remote_payload`.

```rust
use payload_dumper::payload::payload_parser::parse_remote_payload;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = "https://example.com/ota.zip".to_string();

    // Parse remote payload with optional HTTP configuration
    let (manifest, data_offset, content_length) = parse_remote_payload(
        url,
        Some("CustomUserAgent/1.0"),  // User-Agent
        None,                          // Cookies
        None,                          // Custom DNS
    ).await?;

    println!("Remote file size: {} bytes", content_length);
    println!("Data offset: {}", data_offset);
    println!("Partitions found: {}", manifest.partitions.len());

    for partition in &manifest.partitions {
        if let Some(info) = &partition.new_partition_info {
            println!("  {} - {} bytes",
                partition.partition_name,
                info.size.unwrap_or(0)
            );
        }
    }

    Ok(())
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.