feat: AES-256, LTV signatures, PDF/A conversion, PDF/UA validation (#35)

* feat(encryption): add AES-256 (V=5, R=6) encryption

PDF 2.0 AES-256 with SHA-based key derivation, random file encryption
key, and per-object encryption without MD5 key derivation.

* feat(signatures): add LTV signatures with TSA timestamps

CMS signed attributes (content-type, message-digest, signing-time),
RFC 3161 timestamp client, full cert chain support, and timestamp/
revocation detection in verification.

* feat(conversion): add PDF/A conversion with XMP and ICC profile

Converts documents to PDF/A by writing XMP metadata, embedding sRGB
ICC profile, removing JS/actions, and stripping transparency (PDF/A-1).

* feat(validation): add PDF/UA accessibility validation

Checks MarkInfo, Lang, StructTreeRoot, figure alt text, heading
hierarchy, tab order, annotation accessibility, and tagged content.

* feat(wasm): expose AES-256, PDF/A conversion, and PDF/UA validation

Add algorithm parameter to encrypt(), and new validatePdfA(),
validatePdfUa(), and convertToPdfA() WASM bindings.

* docs: update guides, API reference, and type stubs for new features

Add AES-256, LTV signatures, PDF/A conversion, and PDF/UA validation
to security guide, signatures guide, API docs, and TYPE_CHECKING stubs.

* refactor: replace monkey-patching with mixin classes

Convert all 12 feature modules from Document.method = _func monkey-patching
to mixin classes that Document inherits from. Eliminates all type: ignore
[method-assign] comments and the 700-line TYPE_CHECKING stub block in
_document.py. Adds _protocols.py with DocumentBase/PageBase for mypy.

Author: pratyush618

Cargo.toml

@@ -32,4 +32,5 @@ rsa = "0.9"
 p256 = { version = "0.13", features = ["ecdsa"] }
 pkcs8 = "0.10"
 roxmltree = "0.20"
+ureq = "2"
 tokio = { version = "1", features = ["rt-multi-thread"] }

README.md

@@ -42,10 +42,13 @@ md = await doc.ato_markdown()
 - **Metadata & bookmarks** — read and edit document properties and outline
 - **Annotations & watermarks** — add, read, remove annotations; text watermarks
 - **Forms** — inspect, fill, create, and modify form fields
-- **Security** — encryption (AES-128/RC4), sanitization, true content-stream redaction
+- **Security** — encryption (AES-128/256, RC4), sanitization, true content-stream redaction
 - **PDF diff** — text-level comparison of two documents
 - **Layout analysis** — multi-column detection, header/footer identification
 - **Native async** — powered by Rust and tokio, no Python thread pools
+- **Digital signatures** — sign, verify, and inspect with LTV timestamp support
+- **PDF/A** — validation and conversion (XMP, ICC profiles, transparency removal)
+- **PDF/UA** — accessibility validation (structure tree, alt text, tagged content)
 - **WASM playground** — try it in the browser at [docs.byteveda.org/paperjam](https://docs.byteveda.org/paperjam/)
 
 ## Documentation

crates/paperjam-core/Cargo.toml

@@ -26,18 +26,20 @@ image = { workspace = true, optional = true }
 x509-parser = { workspace = true, optional = true }
 cms = { workspace = true, optional = true }
 der = { workspace = true, optional = true }
-sha2 = { workspace = true, optional = true }
+sha2 = { workspace = true }
 spki = { workspace = true, optional = true }
 sha1 = { workspace = true, optional = true }
 rsa = { workspace = true, optional = true }
 p256 = { workspace = true, optional = true }
 pkcs8 = { workspace = true, optional = true }
 roxmltree = { workspace = true, optional = true }
+ureq = { workspace = true, optional = true }
 
 [features]
 default = ["parallel"]
 parallel = ["dep:rayon"]
 mmap = ["dep:memmap2"]
 render = ["dep:pdfium-render", "dep:image"]
-signatures = ["dep:x509-parser", "dep:cms", "dep:der", "dep:sha2", "dep:sha1", "dep:rsa", "dep:p256", "dep:pkcs8", "dep:spki"]
+signatures = ["dep:x509-parser", "dep:cms", "dep:der", "dep:sha1", "dep:rsa", "dep:p256", "dep:pkcs8", "dep:spki"]
+ltv = ["signatures", "dep:ureq"]
 validation = ["dep:roxmltree"]

crates/paperjam-core/data/sRGB.icc

@@ -0,0 +1,39 @@
+//! JavaScript and action removal for PDF/A conversion.
+//!
+//! Reuses logic from the sanitize module.
+
+use crate::document::Document;
+use crate::error::Result;
+use crate::sanitize::{SanitizeOptions, SanitizedItem};
+
+/// Remove JavaScript and prohibited actions for PDF/A compliance.
+///
+/// Returns the list of items that were removed.
+pub fn remove_prohibited_actions(doc: &Document) -> Result<(Document, Vec<String>)> {
+    let options = SanitizeOptions {
+        remove_javascript: true,
+        remove_embedded_files: false,
+        remove_actions: true,
+        remove_links: false,
+    };
+
+    let (sanitized, result) = crate::sanitize::sanitize(doc, &options)?;
+    let mut actions = Vec::new();
+
+    for item in &result.items {
+        actions.push(format_action(item));
+    }
+
+    Ok((sanitized, actions))
+}
+
+fn format_action(item: &SanitizedItem) -> String {
+    if let Some(page) = item.page {
+        format!(
+            "Removed {} on page {}: {}",
+            item.category, page, item.description
+        )
+    } else {
+        format!("Removed {}: {}", item.category, item.description)
+    }
+}

crates/paperjam-core/src/conversion/actions.rs

@@ -0,0 +1,158 @@
+//! PDF/A conversion: convert a document to PDF/A conformance.
+
+mod actions;
+mod output_intent;
+mod transparency;
+mod xmp;
+
+use crate::document::Document;
+use crate::error::{PdfError, Result};
+use crate::validation::{PdfALevel, Severity, ValidationIssue};
+
+/// Options for PDF/A conversion.
+pub struct ConversionOptions {
+    /// Target PDF/A conformance level.
+    pub level: PdfALevel,
+    /// If true, proceed even if some issues (like unembedded fonts) cannot be fixed.
+    pub force: bool,
+}
+
+/// A single action taken during conversion.
+#[derive(Debug, Clone)]
+pub struct ConversionAction {
+    pub category: String,
+    pub description: String,
+    pub page: Option<u32>,
+}
+
+/// Result of a PDF/A conversion.
+#[derive(Debug, Clone)]
+pub struct ConversionResult {
+    pub level: PdfALevel,
+    pub success: bool,
+    pub actions_taken: Vec<ConversionAction>,
+    pub remaining_issues: Vec<ValidationIssue>,
+}
+
+/// Convert a PDF document to PDF/A conformance.
+///
+/// Performs the following transformations:
+/// 1. Removes encryption dictionary (if present)
+/// 2. Writes/updates XMP metadata with PDF/A identification
+/// 3. Adds sRGB OutputIntent with ICC profile (if missing)
+/// 4. Strips JavaScript and prohibited actions
+/// 5. Removes transparency (PDF/A-1 only)
+///
+/// Font embedding is NOT performed — documents with unembedded fonts will
+/// have those reported as remaining issues.
+pub fn convert_to_pdf_a(
+    doc: &Document,
+    options: &ConversionOptions,
+) -> Result<(Document, ConversionResult)> {
+    let mut inner = doc.inner().clone();
+    let mut all_actions = Vec::new();
+
+    // 1. Remove encryption
+    let encryption_actions = remove_encryption(&mut inner);
+    all_actions.extend(encryption_actions);
+
+    // 2. XMP metadata
+    let xmp_actions = xmp::ensure_xmp_metadata(&mut inner, options.level)?;
+    all_actions.extend(xmp_actions);
+
+    // 3. OutputIntent with ICC profile
+    let oi_actions = output_intent::ensure_output_intent(&mut inner)?;
+    all_actions.extend(oi_actions);
+
+    // 4. Remove JS and actions (uses sanitize module, needs a Document wrapper)
+    let temp_doc = Document::from_lopdf(inner)?;
+    let (sanitized_doc, action_descriptions) = actions::remove_prohibited_actions(&temp_doc)?;
+    inner = sanitized_doc.inner().clone();
+    all_actions.extend(action_descriptions);
+
+    // 5. Remove transparency (PDF/A-1 only)
+    if matches!(options.level, PdfALevel::A1b | PdfALevel::A1a) {
+        let page_map = inner.get_pages();
+        let trans_actions = transparency::remove_transparency(&mut inner, &page_map);
+        all_actions.extend(trans_actions);
+    }
+
+    // Build result document
+    let result_doc = Document::from_lopdf(inner)?;
+
+    // Validate the result to find remaining issues
+    let report = crate::validation::validate_pdf_a(&result_doc, options.level)?;
+    let remaining_issues = report.issues;
+
+    // Check for unresolvable issues (like unembedded fonts)
+    let has_errors = remaining_issues
+        .iter()
+        .any(|i| i.severity == Severity::Error);
+
+    if has_errors && !options.force {
+        return Err(PdfError::Conversion(format!(
+            "PDF/A conversion has {} remaining error(s) that cannot be automatically fixed. \
+                 Use force=true to proceed. Issues: {}",
+            remaining_issues
+                .iter()
+                .filter(|i| i.severity == Severity::Error)
+                .count(),
+            remaining_issues
+                .iter()
+                .filter(|i| i.severity == Severity::Error)
+                .map(|i| i.message.as_str())
+                .collect::<Vec<_>>()
+                .join("; "),
+        )));
+    }
+
+    let actions_taken = all_actions
+        .into_iter()
+        .map(|desc| ConversionAction {
+            category: categorize_action(&desc),
+            description: desc,
+            page: None,
+        })
+        .collect();
+
+    Ok((
+        result_doc,
+        ConversionResult {
+            level: options.level,
+            success: !has_errors,
+            actions_taken,
+            remaining_issues,
+        },
+    ))
+}
+
+/// Remove encryption dictionary from the document.
+fn remove_encryption(doc: &mut lopdf::Document) -> Vec<String> {
+    let mut actions = Vec::new();
+
+    if let Ok(encrypt_ref) = doc.trailer.get(b"Encrypt") {
+        if let Ok(id) = encrypt_ref.as_reference() {
+            doc.objects.remove(&id);
+        }
+        doc.trailer.remove(b"Encrypt");
+        actions.push("Removed encryption dictionary".to_string());
+    }
+
+    actions
+}
+
+fn categorize_action(desc: &str) -> String {
+    if desc.contains("XMP") || desc.contains("metadata") {
+        "metadata".to_string()
+    } else if desc.contains("OutputIntent") || desc.contains("ICC") {
+        "color".to_string()
+    } else if desc.contains("encryption") {
+        "encryption".to_string()
+    } else if desc.contains("transparency") || desc.contains("blend") || desc.contains("mask") {
+        "transparency".to_string()
+    } else if desc.contains("javascript") || desc.contains("action") || desc.contains("Removed") {
+        "actions".to_string()
+    } else {
+        "other".to_string()
+    }
+}

crates/paperjam-core/src/conversion/mod.rs

@@ -0,0 +1,97 @@
+//! sRGB ICC profile embedding and OutputIntent creation for PDF/A.
+
+use lopdf::{dictionary, Object};
+
+use crate::error::{PdfError, Result};
+
+/// Embedded sRGB IEC61966-2.1 ICC profile.
+const SRGB_ICC_PROFILE: &[u8] = include_bytes!("../../data/sRGB.icc");
+
+/// Ensure the document has an OutputIntent with an sRGB ICC profile.
+pub fn ensure_output_intent(doc: &mut lopdf::Document) -> Result<Vec<String>> {
+    let mut actions = Vec::new();
+
+    let catalog_id = doc
+        .trailer
+        .get(b"Root")
+        .map_err(|_| PdfError::Conversion("No /Root".to_string()))?
+        .as_reference()
+        .map_err(|_| PdfError::Conversion("/Root not ref".to_string()))?;
+
+    // Check if a PDF/A OutputIntent already exists
+    let has_pdfa_intent = {
+        let catalog = doc
+            .get_object(catalog_id)
+            .map_err(|e| PdfError::Conversion(format!("catalog: {}", e)))?
+            .as_dict()
+            .map_err(|_| PdfError::Conversion("catalog not dict".to_string()))?;
+
+        if let Ok(Object::Array(arr)) = catalog.get(b"OutputIntents") {
+            arr.iter().any(|item| {
+                let d = match item {
+                    Object::Reference(id) => {
+                        doc.get_object(*id).ok().and_then(|o| o.as_dict().ok())
+                    }
+                    Object::Dictionary(d) => Some(d),
+                    _ => None,
+                };
+                d.is_some_and(|d| matches!(d.get(b"S"), Ok(Object::Name(n)) if n == b"GTS_PDFA1"))
+            })
+        } else {
+            false
+        }
+    };
+
+    if has_pdfa_intent {
+        return Ok(actions);
+    }
+
+    // Create ICC profile stream
+    let icc_stream = lopdf::Stream::new(
+        dictionary! {
+            "N" => Object::Integer(3),
+            "Alternate" => Object::Name(b"DeviceRGB".to_vec()),
+            "Length" => Object::Integer(SRGB_ICC_PROFILE.len() as i64)
+        },
+        SRGB_ICC_PROFILE.to_vec(),
+    );
+    let icc_id = doc.add_object(Object::Stream(icc_stream));
+
+    // Create OutputIntent dictionary
+    let output_intent = dictionary! {
+        "Type" => Object::Name(b"OutputIntent".to_vec()),
+        "S" => Object::Name(b"GTS_PDFA1".to_vec()),
+        "OutputConditionIdentifier" => Object::String(
+            b"sRGB IEC61966-2.1".to_vec(),
+            lopdf::StringFormat::Literal,
+        ),
+        "RegistryName" => Object::String(
+            b"http://www.color.org".to_vec(),
+            lopdf::StringFormat::Literal,
+        ),
+        "DestOutputProfile" => Object::Reference(icc_id)
+    };
+    let oi_id = doc.add_object(Object::Dictionary(output_intent));
+
+    // Add to catalog /OutputIntents
+    let catalog = doc
+        .get_object_mut(catalog_id)
+        .map_err(|e| PdfError::Conversion(format!("catalog: {}", e)))?
+        .as_dict_mut()
+        .map_err(|_| PdfError::Conversion("catalog not dict".to_string()))?;
+
+    match catalog.get_mut(b"OutputIntents") {
+        Ok(Object::Array(arr)) => {
+            arr.push(Object::Reference(oi_id));
+        }
+        _ => {
+            catalog.set(
+                "OutputIntents",
+                Object::Array(vec![Object::Reference(oi_id)]),
+            );
+        }
+    }
+
+    actions.push("Added sRGB OutputIntent with ICC profile".to_string());
+    Ok(actions)
+}