Skip to content

Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.

6.6 KB
Raw Blame
use std::fs::File;
use std::io::{Read, Write};
use std::path::Path;

use flate2::read::GzDecoder;
use tar::Archive;

pub fn extract_binary(
    archive_path: &Path,
    asset_name: &str,
    expected_binary_name: &str,
    output_staged_path: &Path,
) -> Result<(), String> {
    if asset_name.ends_with(".tar.gz") || asset_name.ends_with(".tgz") {
        extract_tar_gz(archive_path, expected_binary_name, output_staged_path)
    } else if asset_name.ends_with(".zip") {
        extract_zip(archive_path, expected_binary_name, output_staged_path)
    } else {
        Err(format!("unsupported archive format: {asset_name}"))
    }
}

fn validate_relative_path(path: &Path) -> Result<(), String> {
    if path.is_absolute() {
        return Err("archive entry has absolute path".to_string());
    }

    for component in path.components() {
        match component {
            std::path::Component::ParentDir => {
                return Err("archive entry contains '..' traversal".to_string());
            }
            std::path::Component::Prefix(_) => {
                return Err("archive entry contains volume prefix".to_string());
            }
            std::path::Component::RootDir => {
                return Err("archive entry contains root directory".to_string());
            }
            _ => {}
        }
    }

    Ok(())
}

fn extract_tar_gz(
    archive_path: &Path,
    expected_binary_name: &str,
    output_staged_path: &Path,
) -> Result<(), String> {
    let file = File::open(archive_path).map_err(|e| format!("failed to open archive: {e}"))?;
    let decoder = GzDecoder::new(file);
    let mut archive = Archive::new(decoder);

    let mut found = false;

    for entry_result in archive
        .entries()
        .map_err(|e| format!("corrupt tar archive: {e}"))?
    {
        let mut entry = entry_result.map_err(|e| format!("tar entry read error: {e}"))?;
        let entry_path = entry
            .path()
            .map_err(|e| format!("tar entry path error: {e}"))?
            .to_path_buf();

        validate_relative_path(&entry_path)?;

        let filename = entry_path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("");
        if filename == expected_binary_name {
            let mut out = File::create(output_staged_path)
                .map_err(|e| format!("failed to create staged binary: {e}"))?;
            std::io::copy(&mut entry, &mut out)
                .map_err(|e| format!("failed to write staged binary: {e}"))?;
            out.flush()
                .map_err(|e| format!("failed to flush staged binary: {e}"))?;
            found = true;
            break;
        }
    }

    if !found {
        return Err(format!(
            "binary '{expected_binary_name}' not found inside archive"
        ));
    }

    validate_and_set_permissions(output_staged_path)?;
    Ok(())
}

fn extract_zip(
    archive_path: &Path,
    expected_binary_name: &str,
    output_staged_path: &Path,
) -> Result<(), String> {
    let file = File::open(archive_path).map_err(|e| format!("failed to open zip archive: {e}"))?;
    let mut zip = zip::ZipArchive::new(file).map_err(|e| format!("corrupt zip archive: {e}"))?;

    let mut found = false;

    for i in 0..zip.len() {
        let mut file = zip
            .by_index(i)
            .map_err(|e| format!("zip entry read error: {e}"))?;
        if file.is_dir() {
            continue;
        }

        let enclosed_name = file
            .enclosed_name()
            .ok_or("zip entry path traversal detected")?;
        validate_relative_path(&enclosed_name)?;

        let filename = enclosed_name
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("");
        if filename == expected_binary_name {
            let mut out = File::create(output_staged_path)
                .map_err(|e| format!("failed to create staged binary: {e}"))?;
            let mut buffer = Vec::new();
            file.read_to_end(&mut buffer)
                .map_err(|e| format!("failed to read zip entry data: {e}"))?;
            out.write_all(&buffer)
                .map_err(|e| format!("failed to write staged binary: {e}"))?;
            out.flush()
                .map_err(|e| format!("failed to flush staged binary: {e}"))?;
            found = true;
            break;
        }
    }

    if !found {
        return Err(format!(
            "binary '{expected_binary_name}' not found inside zip"
        ));
    }

    validate_and_set_permissions(output_staged_path)?;
    Ok(())
}

fn validate_and_set_permissions(path: &Path) -> Result<(), String> {
    let metadata =
        std::fs::metadata(path).map_err(|e| format!("staged binary metadata error: {e}"))?;
    if metadata.len() == 0 {
        return Err("extracted binary is empty".to_string());
    }

    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        let mut perms = metadata.permissions();
        perms.set_mode(0o755);
        std::fs::set_permissions(path, perms)
            .map_err(|e| format!("failed to set executable permissions: {e}"))?;
    }

    Ok(())
}
#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Write;
    use zip::write::{SimpleFileOptions, ZipWriter};

    #[test]
    fn test_extract_zip_success() {
        let temp = tempfile::tempdir().unwrap();
        let zip_path = temp.path().join("archive.zip");
        let output_path = temp.path().join("moviebox-tui.exe");

        let file = File::create(&zip_path).unwrap();
        let mut zip = ZipWriter::new(file);
        let options =
            SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
        zip.start_file("moviebox-tui.exe", options).unwrap();
        zip.write_all(b"binary-content-windows").unwrap();
        zip.finish().unwrap();

        extract_zip(&zip_path, "moviebox-tui.exe", &output_path).unwrap();
        let content = std::fs::read(&output_path).unwrap();
        assert_eq!(content, b"binary-content-windows");
    }

    #[test]
    fn test_extract_zip_missing_binary() {
        let temp = tempfile::tempdir().unwrap();
        let zip_path = temp.path().join("archive.zip");
        let output_path = temp.path().join("output.exe");

        let file = File::create(&zip_path).unwrap();
        let mut zip = ZipWriter::new(file);
        let options =
            SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
        zip.start_file("other.exe", options).unwrap();
        zip.write_all(b"other-content").unwrap();
        zip.finish().unwrap();

        let err = extract_zip(&zip_path, "moviebox-tui.exe", &output_path).unwrap_err();
        assert!(err.contains("not found inside zip"));
    }
}