Verschlüsselung und Sicherheit

PDF Oxide unterstützt die Verschlüsselung von PDFs mit Passwörtern und Berechtigungen nach Industriestandard. Sie können ein Benutzerpasswort (zum Öffnen des Dokuments erforderlich), ein Eigentümerpasswort (für vollständigen Zugriff erforderlich) sowie granulare Berechtigungen für Drucken, Kopieren und Ändern festlegen.

Binding-Abdeckung. Das Öffnen verschlüsselter PDFs funktioniert in allen Bindings (password= in Python, PdfDocument.open_with_password in Rust, authenticate() in WASM, Authenticate am PdfDocument in Go/C#, OpenWithPassword in C#). Die Erzeugung verschlüsselter Ausgaben (save_encrypted / saveEncryptedToBytes) steht in Python, Rust, WASM und Go (DocumentEditor.SaveEncrypted) zur Verfügung. Der C#-DocumentEditor stellt SaveEncrypted derzeit nicht bereit — nutzen Sie das Rust-CLI (pdf-oxide encrypt) oder einen Go/Python-Schritt, um verschlüsselte Ausgaben in C#-Workflows zu erzeugen.

Algorithmus-Unterstützung

Algorithmus	Lesen	Schreiben	Hinweise
RC4 (40/128 Bit)	Ja	Ja	Veraltet; nur für Kompatibilität verwenden
AES-128 (V=4, R=4)	Ja	Ja	Standard für PDF 1.6+
AES-256 (V=5, R=6)	Ja	Ja	PDF 2.0; umfasst Entschlüsselung von Strings in unkomprimierten Objekten, /MK /CA-Beschriftungen von Button-Widgets und korrekte Algorithm-2.B-Terminierung

AES-256 wird vollständig End-to-End unterstützt: Öffnen, Authentifizieren, Formulardaten lesen und verschlüsselte Ausgaben speichern. ObjStm- und XRef-Streams werden gemäß ISO 32000-2 §7.6.3 nicht verschlüsselt. Der Objektcache wird nach einem verzögerten authenticate()-Aufruf korrekt ungültig gemacht, sodass vor der Authentifizierung gelesene Inhalte mit dem richtigen Schlüssel neu geparst werden.

Schnellstart: Mit Verschlüsselung speichern

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")?;

Go

package main

import (
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    editor, err := pdfoxide.OpenEditor("input.pdf")
    if err != nil { log.Fatal(err) }
    defer editor.Close()

    _ = editor.SetTitle("Confidential Report")

    // Encrypt with user and owner passwords (AES-256)
    if err := editor.SaveEncrypted("protected.pdf", "user123", "owner456"); err != nil {
        log.Fatal(err)
    }
}

C++

#include <pdf_oxide/pdf_oxide.hpp>

auto editor = pdf_oxide::DocumentEditor::open("input.pdf");

// Encrypt with user and owner passwords (AES-256)
editor.save_encrypted("protected.pdf", "user123", "owner456");

Swift

import PdfOxide

let editor = try DocumentEditor.openEditor("input.pdf")

// Encrypt with user and owner passwords (AES-256)
try editor.saveEncrypted("protected.pdf", userPassword: "user123", ownerPassword: "owner456")

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final editor = DocumentEditor.open('input.pdf');

// Encrypt with user and owner passwords (AES-256)
editor.saveEncrypted('protected.pdf', 'user123', 'owner456');
editor.close();

R

library(pdfoxide)

editor <- pdf_editor_open("input.pdf")

# Encrypt with user and owner passwords (AES-256)
pdf_editor_save_encrypted(editor, "protected.pdf", "user123", "owner456")

Julia

using PdfOxide

editor = open_editor("input.pdf")

# Encrypt with user and owner passwords (AES-256)
save_encrypted(editor, "protected.pdf", "user123", "owner456")

Zig

const pdf_oxide = @import("pdf_oxide");

var editor = try pdf_oxide.DocumentEditor.openEditor("input.pdf");
defer editor.deinit();

// Encrypt with user and owner passwords (AES-256)
try editor.saveEncrypted("protected.pdf", "user123", "owner456");

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"input.pdf" error:&err];

// Encrypt with user and owner passwords (AES-256)
[editor saveEncryptedToPath:@"protected.pdf"
               userPassword:@"user123"
              ownerPassword:@"owner456"
                      error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("input.pdf")

# Encrypt with user and owner passwords (AES-256)
:ok = PdfOxide.editor_save_encrypted(editor, "protected.pdf", "user123", "owner456")

Verschlüsselung mit benutzerdefinierten Berechtigungen

Python

Die Methode save_encrypted akzeptiert Berechtigungs-Flags als Schlüsselwortargumente.

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,
)

Python-Parameter für save_encrypted

Parameter	Typ	Standard	Beschreibung
path	str	erforderlich	Pfad der Ausgabedatei
user_password	str	erforderlich	Öffnungspasswort (leer = kein Passwort)
owner_password	str	None	Vollzugriffspasswort (Standard: wie Benutzerpasswort)
allow_print	bool	True	Drucken erlauben
allow_copy	bool	True	Kopieren von Text/Grafiken erlauben
allow_modify	bool	True	Dokument ändern erlauben
allow_annotate	bool	True	Anmerkungen hinzufügen erlauben

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

Für vollständige Kontrolle über die Verschlüsselungseinstellungen verwenden Sie EncryptionConfig und 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

Das Struct EncryptionConfig steuert alle Verschlüsselungsparameter.

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(),
};

Oder mit dem Builder-Muster:

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

Felder von EncryptionConfig

Feld	Typ	Beschreibung
user_password	String	Passwort zum Öffnen des Dokuments
owner_password	String	Passwort für vollständigen Zugriff und Sicherheitsänderungen
algorithm	EncryptionAlgorithm	Zu verwendender Verschlüsselungsalgorithmus
permissions	Permissions	Zugriffskontroll-Flags

Verschlüsselungsalgorithmen

Algorithmus	Beschreibung
EncryptionAlgorithm::Aes256	AES-256 (stärkste, empfohlen)
EncryptionAlgorithm::Aes128	AES-128
EncryptionAlgorithm::Rc4_128	RC4 128 Bit (Kompatibilität mit Legacy-Systemen)
EncryptionAlgorithm::Rc4_40	RC4 40 Bit (veraltet, schwach)

AES-256 ist der Standard bei Verwendung von save_encrypted() in Python oder der Pdf-API.

Berechtigungen (Permissions)

Das Struct Permissions steuert, welche Operationen erlaubt sind, wenn das Dokument mit dem Benutzerpasswort geöffnet wird.

use pdf_oxide::editor::Permissions;

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

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

Felder von Permissions

Feld	Typ	Standard (all)	Standard (read_only)	Beschreibung
print	bool	true	false	Drucken erlauben
print_high_quality	bool	true	false	Hochqualitätsdruck erlauben
modify	bool	true	false	Inhalte ändern erlauben
copy	bool	true	false	Text/Grafiken kopieren erlauben
annotate	bool	true	false	Anmerkungen hinzufügen erlauben
fill_forms	bool	true	false	Formularfelder ausfüllen erlauben
accessibility	bool	true	true	Barrierefreiheits-Extraktion erlauben
assemble	bool	true	false	Seitenzusammenstellung erlauben

Benutzerdefinierte Berechtigungen

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

Verwenden Sie SaveOptions für vollständige Kontrolle über das Schreiben des Dokuments.

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);

Verschlüsselte PDFs öffnen

Python

Übergeben Sie das Passwort beim Öffnen des Dokuments.

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);

Go

doc, _ := pdfoxide.Open("protected.pdf")
defer doc.Close()
if _, err := doc.Authenticate("user123"); err != nil { log.Fatal(err) }
text, _ := doc.ExtractText(0)
fmt.Println(text)

C#

using var doc = PdfDocument.OpenWithPassword("protected.pdf", "user123");
Console.WriteLine(doc.ExtractText(0));

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <iostream>

auto doc = pdf_oxide::Document::open_with_password("protected.pdf", "user123");
std::cout << doc.extract_text(0) << std::endl;

Swift

import PdfOxide

let doc = try Document.openWithPassword("protected.pdf", password: "user123")
print(try doc.extractText(0))

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final doc = PdfDocument.openWithPassword('protected.pdf', 'user123');
print(doc.extractText(0));
doc.close();

R

library(pdfoxide)

doc <- pdf_open_with_password("protected.pdf", "user123")
cat(pdf_extract_text(doc, 0))

Julia

using PdfOxide

doc = open_with_password("protected.pdf", "user123")
println(extract_text(doc, 0))

Zig

const std = @import("std");
const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

var doc = try pdf_oxide.Document.openWithPassword("protected.pdf", "user123");
defer doc.deinit();
const text = try doc.extractText(a, 0);
std.debug.print("{s}\n", .{text});

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocument *doc = [POXDocument openWithPassword:@"protected.pdf" password:@"user123" error:&err];
NSLog(@"%@", [doc extractText:0 error:&err]);

Elixir

{:ok, doc} = PdfOxide.open_with_password("protected.pdf", "user123")
{:ok, text} = PdfOxide.extract_text(doc, 0)
IO.puts(text)

Vollständiger Verschlüsselungs-Workflow

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)?;

Die vollflächigen Bindings unten speichern die Ausgabe mit AES-256 und vollen Berechtigungen; sie stellen die per-Flag-Berechtigungssteuerung aus Python/WASM/Rust nicht bereit. Setzen Sie /Info-Metadaten über set_producer des Editors vor dem Speichern.

C++

#include <pdf_oxide/pdf_oxide.hpp>

auto editor = pdf_oxide::DocumentEditor::open("report.pdf");
editor.set_producer("Finance Team");

// Save with AES-256 encryption (no open password, owner password for full access)
editor.save_encrypted("report-protected.pdf", "", "admin2025");

Swift

import PdfOxide

let editor = try DocumentEditor.openEditor("report.pdf")
try editor.setProducer("Finance Team")

// Save with AES-256 encryption (no open password, owner password for full access)
try editor.saveEncrypted("report-protected.pdf", userPassword: "", ownerPassword: "admin2025")

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final editor = DocumentEditor.open('report.pdf');
editor.setProducer('Finance Team');

// Save with AES-256 encryption (no open password, owner password for full access)
editor.saveEncrypted('report-protected.pdf', '', 'admin2025');
editor.close();

R

library(pdfoxide)

editor <- pdf_editor_open("report.pdf")
pdf_editor_set_producer(editor, "Finance Team")

# Save with AES-256 encryption (no open password, owner password for full access)
pdf_editor_save_encrypted(editor, "report-protected.pdf", "", "admin2025")

Julia

using PdfOxide

editor = open_editor("report.pdf")
set_producer(editor, "Finance Team")

# Save with AES-256 encryption (no open password, owner password for full access)
save_encrypted(editor, "report-protected.pdf", "", "admin2025")

Zig

const pdf_oxide = @import("pdf_oxide");

var editor = try pdf_oxide.DocumentEditor.openEditor("report.pdf");
defer editor.deinit();
try editor.setProducer("Finance Team");

// Save with AES-256 encryption (no open password, owner password for full access)
try editor.saveEncrypted("report-protected.pdf", "", "admin2025");

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"report.pdf" error:&err];
[editor setProducer:@"Finance Team" error:&err];

// Save with AES-256 encryption (no open password, owner password for full access)
[editor saveEncryptedToPath:@"report-protected.pdf"
               userPassword:@""
              ownerPassword:@"admin2025"
                      error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("report.pdf")
:ok = PdfOxide.set_producer(editor, "Finance Team")

# Save with AES-256 encryption (no open password, owner password for full access)
:ok = PdfOxide.editor_save_encrypted(editor, "report-protected.pdf", "", "admin2025")

Mit anderen Einstellungen neu verschlüsseln

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)?;

Vollständige API-Referenz

Methoden von Pdf

Methode	Rückgabe	Beschreibung
save_encrypted(path, user_pw, owner_pw)	Result<()>	Mit AES-256 und vollen Berechtigungen speichern
save_with_encryption(path, config)	Result<()>	Mit benutzerdefinierter Verschlüsselungskonfiguration speichern

Methoden von DocumentEditor / EditableDocument

Methode	Rückgabe	Beschreibung
save(path)	Result<()>	Mit vollständigem Neuschreiben speichern (keine Verschlüsselung)
save_with_options(path, options)	Result<()>	Mit benutzerdefinierten Optionen speichern

Konfigurationstypen

Typ	Beschreibung
EncryptionConfig	Benutzer-/Eigentümerpasswörter, Algorithmus, Berechtigungen
EncryptionAlgorithm	Aes256, Aes128, Rc4_128, Rc4_40
Permissions	Detaillierte Zugriffskontroll-Flags
SaveOptions	Vollständiges Neuschreiben, inkrementelles Update oder verschlüsseltes Speichern

Verwandte Seiten

• Bearbeitungsübersicht – Öffnen, Metadaten und Speicher-Workflow
• Formularfeld-Bearbeitung – Formularbearbeitung mit Berechtigungen einschränken
• Schwärzung (Redaction) – Inhalte vor der Verschlüsselung schwärzen
• Seitenoperationen – Seiten vor der finalen Verschlüsselung vorbereiten