Encriptación

PDF Oxide soporta la encriptación de PDFs con contraseñas y permisos usando algoritmos estándar de la industria. Puede establecer una contraseña de usuario (requerida para abrir el documento), una contraseña de propietario (requerida para acceso completo) y permisos detallados que controlan la impresión, copia y modificación.

Inicio rápido: guardar con encriptación

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("input.pdf")
doc.set_title("Confidential Report")

# Encrypt with user and owner passwords
doc.save_encrypted("protected.pdf", "user123", "owner456")

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const doc = new WasmPdfDocument(bytes);
doc.setTitle("Confidential Report");

// Encrypt with user and owner passwords (all permissions enabled)
const output = doc.saveEncryptedToBytes(
  "user123", "owner456", true, true, true, true
);
doc.free();

Rust

use pdf_oxide::api::Pdf;

let mut doc = Pdf::open("input.pdf")?;

// Simple encryption with user and owner passwords
doc.save_encrypted("protected.pdf", "user123", "owner456")?;

Encriptación con permisos personalizados

Python

El método save_encrypted acepta indicadores de permisos como argumentos con nombre.

from pdf_oxide import PdfDocument

doc = PdfDocument("input.pdf")

# View-only: no printing, copying, or modifying
doc.save_encrypted(
    "readonly.pdf",
    "viewpass",
    "adminpass",
    allow_print=False,
    allow_copy=False,
    allow_modify=False,
    allow_annotate=False,
)

# Allow only printing
doc.save_encrypted(
    "print-only.pdf",
    "",            # No open password required
    "adminpass",
    allow_print=True,
    allow_copy=False,
    allow_modify=False,
    allow_annotate=False,
)

Parámetros de save_encrypted en Python

Parámetro	Tipo	Predeterminado	Descripción
path	str	requerido	Ruta del archivo de salida
user_password	str	requerido	Contraseña para abrir (vacío = sin contraseña de apertura)
owner_password	str	None	Contraseña de acceso completo (predeterminada a contraseña de usuario)
allow_print	bool	True	Permitir impresión
allow_copy	bool	True	Permitir copiar texto/gráficos
allow_modify	bool	True	Permitir modificar el documento
allow_annotate	bool	True	Permitir agregar anotaciones

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const doc = new WasmPdfDocument(bytes);

// View-only: no printing, copying, or modifying
const readonly = doc.saveEncryptedToBytes(
  "viewpass", "adminpass", false, false, false, false
);

// Allow only printing (empty user password = no open password)
const printOnly = doc.saveEncryptedToBytes(
  "", "adminpass", true, false, false, false
);
doc.free();

Rust

Para control completo sobre la configuración de encriptación, use EncryptionConfig y SaveOptions.

use pdf_oxide::api::Pdf;
use pdf_oxide::editor::{
    EncryptionConfig, EncryptionAlgorithm, Permissions, SaveOptions,
};

let mut doc = Pdf::open("input.pdf")?;

// Build permissions
let mut perms = Permissions::read_only();
perms.print = true;  // Allow printing only

// Build encryption config
let config = EncryptionConfig::new("user123", "owner456")
    .with_algorithm(EncryptionAlgorithm::Aes256)
    .with_permissions(perms);

// Save with encryption
doc.save_with_encryption("protected.pdf", config)?;

EncryptionConfig

La estructura EncryptionConfig controla todos los parámetros de encriptación.

use pdf_oxide::editor::{EncryptionConfig, EncryptionAlgorithm, Permissions};

let config = EncryptionConfig {
    user_password: "user123".to_string(),
    owner_password: "owner456".to_string(),
    algorithm: EncryptionAlgorithm::Aes256,
    permissions: Permissions::all(),
};

O use el patrón builder:

let config = EncryptionConfig::new("user123", "owner456")
    .with_algorithm(EncryptionAlgorithm::Aes128)
    .with_permissions(Permissions::read_only());

Campos de EncryptionConfig

Campo	Tipo	Descripción
user_password	String	Contraseña requerida para abrir el documento
owner_password	String	Contraseña para acceso completo y cambio de seguridad
algorithm	EncryptionAlgorithm	Algoritmo de encriptación a usar
permissions	Permissions	Indicadores de control de acceso

Algoritmos de encriptación

Algorithm	Descripción
EncryptionAlgorithm::Aes256	AES-256 (más fuerte, recomendado)
EncryptionAlgorithm::Aes128	AES-128
EncryptionAlgorithm::Rc4_128	RC4 128 bits (compatibilidad legado)
EncryptionAlgorithm::Rc4_40	RC4 40 bits (legado, débil)

AES-256 es el predeterminado cuando se usa save_encrypted() en Python o la API de Pdf.

Permisos

La estructura Permissions controla qué operaciones están permitidas cuando un documento se abre con la contraseña de usuario.

use pdf_oxide::editor::Permissions;

// Allow everything
let all = Permissions::all();

// Restrict everything
let readonly = Permissions::read_only();

Campos de Permisos

Field	Type	Default (all)	Default (read_only)	Descripción
print	bool	true	false	Permitir impresión
print_high_quality	bool	true	false	Permitir impresión de alta calidad
modify	bool	true	false	Permitir modificar contenido
copy	bool	true	false	Permitir copiar texto/gráficos
annotate	bool	true	false	Permitir agregar anotaciones
fill_forms	bool	true	false	Permitir llenar campos de formulario
accessibility	bool	true	true	Permitir extracción de accesibilidad
assemble	bool	true	false	Permitir operaciones de ensamblaje de páginas

Permisos personalizados

let mut perms = Permissions::read_only();
perms.print = true;          // Allow printing
perms.fill_forms = true;     // Allow filling forms
perms.accessibility = true;  // Always allow for compliance

SaveOptions

Use SaveOptions para control completo sobre cómo se escribe el documento.

use pdf_oxide::editor::{SaveOptions, EncryptionConfig};

// Full rewrite (default)
let opts = SaveOptions::full_rewrite();

// Incremental update (faster, preserves structure)
let opts = SaveOptions::incremental();

// With encryption
let config = EncryptionConfig::new("user", "owner");
let opts = SaveOptions::with_encryption(config);

Abrir PDFs encriptados

Python

Pase la contraseña al abrir el documento.

from pdf_oxide import PdfDocument

doc = PdfDocument("protected.pdf", password="user123")
text = doc.extract_text(0)
print(text)

Rust

use pdf_oxide::PdfDocument;

let doc = PdfDocument::open_with_password("protected.pdf", "user123")?;
let text = doc.extract_text(0)?;
println!("{}", text);

Flujo de trabajo de encriptación completo

Python

from pdf_oxide import PdfDocument

# Open and modify
doc = PdfDocument("report.pdf")
doc.set_title("Confidential Report")
doc.set_author("Finance Team")

# Save with view-only restrictions
doc.save_encrypted(
    "report-protected.pdf",
    "",            # No password to open
    "admin2025",   # Owner password for full access
    allow_print=True,
    allow_copy=False,
    allow_modify=False,
)

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const doc = new WasmPdfDocument(bytes);
doc.setTitle("Confidential Report");
doc.setAuthor("Finance Team");

// Save with view-only restrictions (no open password, print allowed)
const output = doc.saveEncryptedToBytes(
  "", "admin2025", true, false, false, false
);
doc.free();

Rust

use pdf_oxide::api::Pdf;
use pdf_oxide::editor::{
    DocumentEditor, EditableDocument,
    EncryptionConfig, EncryptionAlgorithm, Permissions, SaveOptions,
};

// Open and modify
let mut doc = Pdf::open("report.pdf")?;
{
    let editor = doc.editor().unwrap();
    editor.set_title("Confidential Report");
    editor.set_author("Finance Team");
}

// Configure encryption
let permissions = Permissions {
    print: true,
    print_high_quality: true,
    modify: false,
    copy: false,
    annotate: false,
    fill_forms: true,
    accessibility: true,
    assemble: false,
};

let config = EncryptionConfig::new("", "admin2025")
    .with_algorithm(EncryptionAlgorithm::Aes256)
    .with_permissions(permissions);

doc.save_with_encryption("report-protected.pdf", config)?;

Re-encriptar con configuración diferente

Rust

use pdf_oxide::editor::{DocumentEditor, EditableDocument, EncryptionConfig, SaveOptions};

// Open with current password
let mut editor = DocumentEditor::open("old-protected.pdf")?;

// Save with new encryption
let config = EncryptionConfig::new("newuser", "newowner");
let options = SaveOptions::with_encryption(config);
editor.save_with_options("re-encrypted.pdf", options)?;

Referencia completa de la API

Métodos de Pdf

Método	Retorna	Descripción
save_encrypted(path, user_pw, owner_pw)	Result<()>	Guardar con AES-256 y permisos completos
save_with_encryption(path, config)	Result<()>	Guardar con configuración de encriptación personalizada

Métodos de DocumentEditor / EditableDocument

Método	Retorna	Descripción
save(path)	Result<()>	Guardar con reescritura completa (sin encriptación)
save_with_options(path, options)	Result<()>	Guardar con opciones personalizadas

Tipos de configuración

Type	Descripción
EncryptionConfig	Contraseñas de usuario/propietario, algoritmo, permisos
EncryptionAlgorithm	Aes256, Aes128, Rc4_128, Rc4_40
Permissions	Indicadores de control de acceso detallado
SaveOptions	Reescritura completa, incremental o guardado encriptado

Páginas relacionadas

• Editing Overview – apertura, metadatos y flujo de trabajo de guardado
• Form Field Editing – restringir edición de formularios con permisos
• Redaction – redactar contenido antes de encriptar
• Page Operations – preparar páginas antes de la encriptación final