html2pdf_secure/

encryption.rs

//! PDF encryption and password protection functionality.

use crate::error::Result;
use lopdf::Document;
use serde::{Deserialize, Serialize};
use rand::Rng;

/// Password options for PDF encryption.
#[derive(Debug, Clone)]
pub struct PasswordOptions {
    /// User password (for opening the document)
    pub user_password: String,
    
    /// Owner password (for full access/editing)
    pub owner_password: String,
    
    /// Encryption level
    pub encryption_level: EncryptionLevel,
    
    /// Permissions for the document
    pub permissions: PdfPermissions,
}

impl PasswordOptions {
    /// Create new password options with user and owner passwords.
    /// Uses AES-256 encryption by default for maximum security.
    pub fn new<S1: Into<String>, S2: Into<String>>(user_password: S1, owner_password: S2) -> Self {
        Self {
            user_password: user_password.into(),
            owner_password: owner_password.into(),
            encryption_level: EncryptionLevel::Aes256, // Use strong encryption by default
            permissions: PdfPermissions::default(),
        }
    }
    
    /// Set the encryption level.
    pub fn with_encryption_level(mut self, level: EncryptionLevel) -> Self {
        self.encryption_level = level;
        self
    }
    
    /// Set the permissions.
    pub fn with_permissions(mut self, permissions: PdfPermissions) -> Self {
        self.permissions = permissions;
        self
    }
}

/// Encryption levels supported.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EncryptionLevel {
    /// Standard 40-bit RC4 encryption
    Standard40,
    /// Standard 128-bit RC4 encryption
    Standard128,
    /// AES 128-bit encryption
    Aes128,
    /// AES 256-bit encryption
    Aes256,
}

/// PDF permissions configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PdfPermissions {
    /// Allow printing
    pub allow_printing: bool,
    
    /// Allow modifying the document
    pub allow_modify_contents: bool,
    
    /// Allow copying text and graphics
    pub allow_copy: bool,
    
    /// Allow adding or modifying annotations
    pub allow_modify_annotations: bool,
    
    /// Allow filling in form fields
    pub allow_fill_forms: bool,
    
    /// Allow extracting text and graphics for accessibility
    pub allow_extract_for_accessibility: bool,
    
    /// Allow assembling the document
    pub allow_assemble: bool,
    
    /// Allow high-quality printing
    pub allow_print_high_quality: bool,
}

impl Default for PdfPermissions {
    fn default() -> Self {
        Self {
            allow_printing: true,
            allow_modify_contents: false,
            allow_copy: true,
            allow_modify_annotations: false,
            allow_fill_forms: true,
            allow_extract_for_accessibility: true,
            allow_assemble: false,
            allow_print_high_quality: true,
        }
    }
}

impl PdfPermissions {
    /// Create permissions that allow everything.
    pub fn allow_all() -> Self {
        Self {
            allow_printing: true,
            allow_modify_contents: true,
            allow_copy: true,
            allow_modify_annotations: true,
            allow_fill_forms: true,
            allow_extract_for_accessibility: true,
            allow_assemble: true,
            allow_print_high_quality: true,
        }
    }
    
    /// Create permissions that deny everything except viewing.
    pub fn deny_all() -> Self {
        Self {
            allow_printing: false,
            allow_modify_contents: false,
            allow_copy: false,
            allow_modify_annotations: false,
            allow_fill_forms: false,
            allow_extract_for_accessibility: false,
            allow_assemble: false,
            allow_print_high_quality: false,
        }
    }
    
    /// Convert permissions to PDF permission flags.
    pub fn to_permission_flags(&self) -> i32 {
        let mut flags = 0i32;
        
        if self.allow_printing { flags |= 1 << 2; }
        if self.allow_modify_contents { flags |= 1 << 3; }
        if self.allow_copy { flags |= 1 << 4; }
        if self.allow_modify_annotations { flags |= 1 << 5; }
        if self.allow_fill_forms { flags |= 1 << 8; }
        if self.allow_extract_for_accessibility { flags |= 1 << 9; }
        if self.allow_assemble { flags |= 1 << 10; }
        if self.allow_print_high_quality { flags |= 1 << 11; }
        
        flags
    }
}

/// Apply password protection to a PDF document.
///
/// **Important**: This function attempts to use qpdf first for proper encryption.
/// If qpdf is not available, it falls back to an unencrypted PDF with a warning.
///
/// For guaranteed password protection, use `encrypt_pdf_with_qpdf` directly
/// and handle the error if qpdf is not available.
pub fn encrypt_pdf(pdf_data: Vec<u8>, password_options: &PasswordOptions) -> Result<Vec<u8>> {
    // Try qpdf first
    match encrypt_pdf_with_qpdf(pdf_data.clone(), password_options, None) {
        Ok(encrypted_data) => {
            log::info!("Successfully encrypted PDF using qpdf");
            Ok(encrypted_data)
        }
        Err(e) => {
            log::warn!("qpdf encryption failed: {}", e);
            log::warn!("Falling back to unencrypted PDF");
            log::warn!("Install qpdf for proper password protection: https://qpdf.sourceforge.io/");

            // Return unencrypted PDF with warning
            encrypt_pdf_fallback(pdf_data, password_options)
        }
    }
}

/// Fallback function that returns an unencrypted PDF with clear warnings.
/// This is used when qpdf is not available.
fn encrypt_pdf_fallback(pdf_data: Vec<u8>, password_options: &PasswordOptions) -> Result<Vec<u8>> {
    // Load the PDF document
    let mut doc = Document::load_mem(&pdf_data)?;

    // Log the encryption attempt
    log::error!("⚠️  WARNING: PDF is NOT password protected!");
    log::error!("⚠️  qpdf is required for password protection but was not found");
    log::error!("⚠️  Install qpdf to enable password protection:");
    log::error!("   - Ubuntu/Debian: sudo apt-get install qpdf");
    log::error!("   - macOS: brew install qpdf");
    log::error!("   - Windows: Download from https://qpdf.sourceforge.io/");

    log::info!("Requested encryption settings (NOT APPLIED):");
    log::info!("  User password length: {}", password_options.user_password.len());
    log::info!("  Owner password length: {}", password_options.owner_password.len());
    log::info!("  Encryption level: {:?}", password_options.encryption_level);

    // Save the document without encryption
    let mut output = Vec::new();
    doc.save_to(&mut output)?;

    Ok(output)
}

/// Apply password protection using external qpdf tool (if available).
/// This is a more robust solution for production use.
///
/// # Prerequisites
/// - qpdf must be installed on the system
/// - Sufficient disk space for temporary files
///
/// # Arguments
/// - `pdf_data`: The PDF data to encrypt
/// - `password_options`: Password and encryption settings
/// - `temp_dir`: Optional temporary directory (defaults to /tmp)
///
/// # Returns
/// - `Ok(Vec<u8>)`: Encrypted PDF data
/// - `Err(Html2PdfError)`: If qpdf is not available or encryption fails
pub fn encrypt_pdf_with_qpdf(
    pdf_data: Vec<u8>,
    password_options: &PasswordOptions,
    temp_dir: Option<&str>
) -> Result<Vec<u8>> {
    use std::process::Command;
    use std::fs;

    // First check if qpdf is available
    let qpdf_check = Command::new("qpdf")
        .arg("--version")
        .output();

    match qpdf_check {
        Ok(output) if output.status.success() => {
            log::info!("qpdf found: {}", String::from_utf8_lossy(&output.stdout).trim());
        }
        Ok(_) => {
            return Err(crate::error::Html2PdfError::encryption(
                "qpdf command failed - may not be properly installed".to_string()
            ));
        }
        Err(_) => {
            return Err(crate::error::Html2PdfError::encryption(
                "qpdf not found - install qpdf for password protection".to_string()
            ));
        }
    }

    // Create temporary directory
    let temp_dir = temp_dir.unwrap_or("/tmp");
    let mut rng = rand::rng();
    let input_path = format!("{}/input_{}.pdf", temp_dir, rng.random::<u32>());
    let output_path = format!("{}/output_{}.pdf", temp_dir, rng.random::<u32>());

    // Write input PDF to temporary file
    fs::write(&input_path, &pdf_data)?;

    // Build qpdf command based on encryption level
    let mut cmd = Command::new("qpdf");

    match password_options.encryption_level {
        EncryptionLevel::Standard40 => {
            // 40-bit RC4 (very weak, requires --allow-weak-crypto)
            cmd.arg("--allow-weak-crypto")
               .arg("--encrypt")
               .arg(&password_options.user_password)
               .arg(&password_options.owner_password)
               .arg("40")
               .arg("--")
               .arg(&input_path)
               .arg(&output_path);
        }
        EncryptionLevel::Standard128 => {
            // 128-bit RC4 (weak, requires --allow-weak-crypto)
            cmd.arg("--allow-weak-crypto")
               .arg("--encrypt")
               .arg(&password_options.user_password)
               .arg(&password_options.owner_password)
               .arg("128")
               .arg("--")
               .arg(&input_path)
               .arg(&output_path);
        }
        EncryptionLevel::Aes128 => {
            // 128-bit AES (modern, secure)
            cmd.arg("--encrypt")
               .arg(&password_options.user_password)
               .arg(&password_options.owner_password)
               .arg("128")
               .arg("--use-aes=y")
               .arg("--")
               .arg(&input_path)
               .arg(&output_path);
        }
        EncryptionLevel::Aes256 => {
            // 256-bit AES (strongest, recommended)
            cmd.arg("--encrypt")
               .arg(&password_options.user_password)
               .arg(&password_options.owner_password)
               .arg("256")
               .arg("--")
               .arg(&input_path)
               .arg(&output_path);
        }
    }

    // Execute qpdf
    let output = cmd.output();

    // Clean up input file
    let _ = fs::remove_file(&input_path);

    match output {
        Ok(result) => {
            if result.status.success() {
                // Read encrypted PDF
                let encrypted_data = fs::read(&output_path)?;
                // Clean up output file
                let _ = fs::remove_file(&output_path);
                Ok(encrypted_data)
            } else {
                // Clean up output file if it exists
                let _ = fs::remove_file(&output_path);
                Err(crate::error::Html2PdfError::encryption(format!(
                    "qpdf failed: {}",
                    String::from_utf8_lossy(&result.stderr)
                )))
            }
        }
        Err(e) => {
            // Clean up output file if it exists
            let _ = fs::remove_file(&output_path);
            Err(crate::error::Html2PdfError::encryption(format!(
                "Failed to execute qpdf: {}. Make sure qpdf is installed.", e
            )))
        }
    }
}