Security

Security

Den här sidan behandlar lösenord, kryptering och digitala signaturer. Document.OpenFile() / Document.Open() accepterar ett lösenord för att öppna ett skyddat dokument, Document.Save() accepterar ett encrypt-alternativ för att skydda ett, och Document.Sign() / Document.Certify() / Document.VerifySignatures() lägger till och kontrollerar digitala signaturer.

Öppna och dekryptera lösenordsskyddade dokument

Skicka { password: '...' } till Document.OpenFile() eller Document.Open() för att öppna ett dokument som är skyddat med ett användarlösenord. Om lösenordet saknas eller är felaktigt kastar anropet InvalidPasswordError.

import { Document, InvalidPasswordError } from '@asposefoss/pdf';

try {
  const doc = Document.OpenFile('secret.pdf', { password: 'hunter2' });
  doc.WriteTo('decrypted.pdf');    // output is plaintext
} catch (e) {
  if (e instanceof InvalidPasswordError) console.error('wrong password');
  else throw e;
}

Kryptera vid sparande

Document.Save() (och Document.WriteTo()) accepterar ett encrypt-alternativ. Lösenordsbaserad kryptering är det vanliga fallet; biblioteket stöder också kryptering med offentliga nycklar till en eller flera mottagarcertifikat, som öppnas igen med mottagarens privata nyckel.

// Encrypt to one or more recipient certificates (PEM string or DER bytes):
const bytes = doc.Save({
  encrypt: {
    recipients: [{ certificate: recipientCertPem }],
    algorithm: 'aes256',                 // 'aes256' (default) | 'aes128' | 'rc4'
    permissions: { copying: false },     // shared across all recipients
  },
});

// Open with the recipient's private key + certificate, or a PKCS#12 bundle:
const opened = Document.Open(bytes, {
  recipient: { privateKey, certificate: recipientCertPem },
});
console.log(opened.Permissions);         // recovered permission flags (not enforced)

Signering och certifiering

Document.Certify() lägger till en certifierings-(författar-)signatur som bär en DocMDP transform som deklarerar vilka senare ändringar som är tillåtna; Document.Sign() lägger till en ytterligare, vanlig godkännandesignatur som kan bifogas inkrementellt ovanpå. Båda tar en { certificate, privateKey } signer och ett options-objekt (reason, location, name, fieldName, och — för Certify() — permissions).

const certifying = Document.OpenFile('report.pdf');
await certifying.Certify(
  { certificate: author.certificate, privateKey: author.privateKey },
  { permissions: 'form-fill', reason: 'Certifying the report', fieldName: 'Certification' },
);
const certifiedBytes = certifying.Save();

const approving = Document.Open(certifiedBytes);
await approving.Sign(
  { certificate: approver.certificate, privateKey: approver.privateKey },
  { reason: 'Approved for publication', fieldName: 'Approval' },
);
approving.WriteTo('signed.pdf');

Verifiera signaturer

Document.VerifySignatures() kontrollerar varje signatur i dokumentet: den beräknar om varje /ByteRange digest, verifierar den fristående CMS, och rapporterar vad som ändrats efter varje signatur. Den returnerar en SignatureReport[], ett objekt per signatur.

const reports = await Document.OpenFile('signed.pdf').VerifySignatures();
for (const r of reports) {
  console.log(r.name, 'integrity:', r.integrity, 'signature:', r.signature);
}

Tips och bästa praxis

• Fånga InvalidPasswordError specifikt innan en bredare catch-all när du öppnar opålitlig indata, så att du kan reagera annorlunda på ett felaktigt lösenord än på en korrupt fil.
• Anropa Certify() innan några Sign()-anrop — en certifieringssignatur fastställer DocMDP-behörigheterna som senare godkännandesignaturer byggs ovanpå.
• Document.Open() returnerar återställda Permissions efter offentlig nyckel-dekryptering, men biblioteket verkställer dem inte självt — behandla dem som informativa.
• VerifySignatures() är async — await den (eller hantera det returnerade Promise) innan du läser rapport-arrayen.

Vanliga problem

FAQ

Vad är skillnaden mellan Sign och Certify?

Certify() lägger till den första, certifieringssignaturen och deklarerar (via en DocMDP transform) vilka senare ändringar som är tillåtna. Sign() lägger till en vanlig godkännandesignatur, som läggs till stegvis ovanpå allt som kom före den.

Hur öppnar jag en lösenordsskyddad PDF?

Skicka { password: '...' } till Document.OpenFile() eller Document.Open(), och fånga InvalidPasswordError om lösenordet kan vara fel.

Tillämpar detta bibliotek PDF-behörighetsflaggor?

Nej. Document.Open() återställer Permissions-flaggorna från ett krypterat dokument så att du kan granska dem, men begränsar inte själva vad din kod kan göra med det öppnade dokumentet.

Hur kontrollerar jag om signaturerna i en signerad PDF fortfarande är giltiga?

Anropa Document.VerifySignatures() (en async metod) och inspektera varje returnerad SignatureReports integrity och signature fält.

API Reference Sammanfattning

Se även

• Aspose.PDF — Enterprise Documentation