Function analyze_file 

pub fn analyze_file(path: &PathBuf) -> Result<SecurityCheck>

Analyze a single executable file for security features

This function detects the executable format and performs appropriate security analysis.

Arguments

• path - Path to the executable file to analyze

Returns

Returns a SecurityCheck struct containing the analysis results, or an error if the file cannot be read or is not a supported executable format.

Example

use execheck::analyze_file;
use std::path::PathBuf;

let result = analyze_file(&PathBuf::from("/bin/ls"))?;
println!("Security status: {}", result.overall_status);

Examples found in repository

examples/simple_analysis.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Analyze a single executable file
    let file_path = PathBuf::from("/bin/ls");
    
    println!("Analyzing: {}", file_path.display());
    
    match analyze_file(&file_path) {
        Ok(result) => {
            println!("\n=== Analysis Results ===");
            println!("File: {}", result.file_path);
            println!("Type: {}", result.file_type);
            println!("Status: {}", result.overall_status);
            
            println!("\n=== Security Checks ===");
            for (check, value) in &result.checks {
                println!("  {}: {}", check, value);
            }
            
            // Create a report and print it in human-readable format
            println!("\n=== Formatted Report ===");
            let report = SecurityReport {
                files: vec![result],
                summary: ReportSummary {
                    total_files: 1,
                    secure_files: 1,
                    insecure_files: 0,
                    unsupported_files: 0,
                },
            };
            
            print_report(&report, &OutputFormat::Human, None)?;
        }
        Err(e) => {
            eprintln!("Failed to analyze file: {}", e);
            std::process::exit(1);
        }
    }
    
    Ok(())
}

examples/json_output.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Analyze multiple files
    let files = vec![
        PathBuf::from("/bin/ls"),
        PathBuf::from("/bin/cat"),
        PathBuf::from("/bin/echo"),
    ];
    
    let mut results = Vec::new();
    let mut secure_count = 0;
    let mut insecure_count = 0;
    let mut unsupported_count = 0;
    
    println!("Analyzing {} files...", files.len());
    
    for file_path in files {
        match analyze_file(&file_path) {
            Ok(result) => {
                match result.overall_status.as_str() {
                    "Secure" => secure_count += 1,
                    "Mostly Secure" | "Insecure" => insecure_count += 1,
                    _ => unsupported_count += 1,
                }
                results.push(result);
            }
            Err(e) => {
                eprintln!("Warning: Failed to analyze {}: {}", file_path.display(), e);
                unsupported_count += 1;
            }
        }
    }
    
    // Create report
    let report = SecurityReport {
        files: results,
        summary: ReportSummary {
            total_files: secure_count + insecure_count + unsupported_count,
            secure_files: secure_count,
            insecure_files: insecure_count,
            unsupported_files: unsupported_count,
        },
    };
    
    println!("\n=== JSON Output ===");
    print_report(&report, &OutputFormat::Json, None)?;
    
    Ok(())
}

examples/fat_binary_analysis.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== ExeCheck Fat Binary Analysis Example ===");
    println!();
    
    // Example fat binary paths (these may not exist on all systems)
    let potential_fat_binaries = vec![
        "/Applications/Xcode.app/Contents/MacOS/Xcode",
        "/System/Applications/Calculator.app/Contents/MacOS/Calculator",
        "/usr/bin/python3",
        "/bin/bash",
    ];
    
    println!("Searching for fat binaries on the system...");
    println!();
    
    let mut found_examples = false;
    
    for binary_path in potential_fat_binaries {
        let path = PathBuf::from(binary_path);
        
        if path.exists() {
            println!("Analyzing: {}", binary_path);
            
            match analyze_file(&path) {
                Ok(result) => {
                    // Check if this is a fat binary
                    if result.file_type.contains("Fat") {
                        found_examples = true;
                        
                        println!("✅ Found fat binary!");
                        println!("   File Type: {}", result.file_type);
                        println!("   Status: {}", result.overall_status);
                        
                        if let Some(arch_count) = result.checks.get("architectures") {
                            println!("   Architectures: {}", arch_count);
                        }
                        
                        // Show per-architecture security details
                        if let Some(total_archs) = result.checks.get("total_architectures") {
                            println!("   Total Architectures: {}", total_archs);
                        }
                        if let Some(secure_archs) = result.checks.get("secure_architectures") {
                            println!("   Secure Architectures: {}", secure_archs);
                        }
                        if let Some(arch_list) = result.checks.get("architectures") {
                            println!("   Architecture List: {}", arch_list);
                        }
                        
                        // Show individual architecture security checks
                        println!("   Per-Architecture Security:");
                        for (key, value) in &result.checks {
                            if key.contains("_pie") || key.contains("_canary") || key.contains("_nx") {
                                println!("     {}: {}", key, value);
                            }
                        }
                        
                        println!();
                        
                        // Show detailed report in JSON format
                        println!("Detailed JSON Report:");
                        print_report(&execheck::SecurityReport {
                            files: vec![result],
                            summary: execheck::ReportSummary {
                                total_files: 1,
                                secure_files: 0,
                                insecure_files: 0,
                                unsupported_files: 1,
                            },
                        }, &OutputFormat::Json, None)?;
                        
                        println!("\n{}\n", "=".repeat(60));
                    } else {
                        println!("   Not a fat binary ({})", result.file_type);
                    }
                }
                Err(e) => {
                    println!("   Error analyzing: {}", e);
                }
            }
        } else {
            println!("Skipping: {} (not found)", binary_path);
        }
    }
    
    if !found_examples {
        // Create a demonstration with mock data
        println!("No fat binaries found on system. Showing example output:");
        println!();
        
        demonstrate_fat_binary_output()?;
    }
    
    println!("=== Fat Binary Analysis Notes ===");
    println!();
    println!("Current Status:");
    println!("• ✅ Fat binary detection and architecture counting");
    println!("• ✅ Per-architecture security analysis"); 
    println!("• ✅ Architecture-specific security checks (e.g., 'x86_64_pie', 'arm64_canary')");
    println!("• ✅ Combined security status (Secure/Mixed/Insecure)");
    println!();
    println!("Fat binaries now show detailed architecture-specific security analysis,");
    println!("allowing you to see security features for each architecture independently.");
    
    Ok(())
}