Hur man lägger till PDF-säkerhetsunderskrifter i Python

Aspose.PDF FOSS för Python inkluderar en signaturkompromissdetektor som granskar en redan signerad PDF för ett specifikt manipuleringsmönster: meningsfulla byte som läggs till efter signaturens signerade byteintervall, en risk som är unik för inkrementellt uppdaterade PDF-filer. Denna guide lägger till den kontrollen i ett Python-arbetsflöde med hjälp av klasserna SignaturesCompromiseDetector och CompromiseCheckResult. Att skapa eller tillämpa nya digitala signaturer är en separat del av biblioteket och behandlas inte här. Biblioteket installeras med kommandot nedan.

Steg-för-steg guide

Steg 1: Installera paketet

Installera Aspose.PDF FOSS-paketet:

git clone https://github.com/aspose-pdf-foss/Aspose-PDF-FOSS-for-Python.git
cd Aspose-PDF-FOSS-for-Python
pip install -e .

Verifiera installationen genom att importera SignaturesCompromiseDetector och skriva ut ett bekräftelsemeddelande:

from aspose_pdf import SignaturesCompromiseDetector
print("aspose-pdf-foss-for-python is ready.")

Steg 2: Importera nödvändiga klasser

from aspose_pdf import CompromiseCheckResult, SignaturesCompromiseDetector

Steg 3: Förbered ett objekt som exponerar en signaturlista

SignaturesCompromiseDetector analyserar inte en PDF själv — dess konstruktor accepterar vilket objekt som helst som exponerar ett signatures-attribut: en lista med signaturposter, där varje innehåller valid, byte_range och reference_data. PdfSignature — en enkel, direkt konstruerbar klass — matchar den strukturen, så den är användbar för att se hur kontrollen beter sig innan du kopplar den till ditt eget dokumentobjekt:

from types import SimpleNamespace
from aspose_pdf import PdfSignature

with open("signed.pdf", "rb") as handle:
    pdf_bytes = handle.read()

signature = PdfSignature(
    name="Signature1",
    contents=b"...",  # PKCS#7 signed-data blob from the signature dictionary
    byte_range=[0, 1024, 1040, len(pdf_bytes) - 1040],
    reference_data=pdf_bytes,
)

signed_document = SimpleNamespace(signatures=[signature])

Byt ut signed_document mot ditt eget dokumentobjekt när det exponerar en signatures-lista i samma form — vilket objekt som helst med det attributet fungerar.

Steg 4: Kör kompromisskontrollen

from aspose_pdf import SignaturesCompromiseDetector

detector = SignaturesCompromiseDetector(signed_document)
result = detector.check()

print(result.compromised)                # bool
print(result.has_compromised_signatures)  # bool -- same value as compromised
print(result.signatures_coverage)         # int -- number of signatures inspected
print(result.reasons)                     # list[str] -- human-readable findings

check() går igenom varje signatur i signed_document.signatures, och letar efter osignerat innehåll som lagts till efter varje signaturs signerade byteintervall. En CompromiseCheckResult sammanfattar resultatet: compromised och has_compromised_signatures rapporterar samma booleska värde under två namn, signatures_coverage rapporterar hur många signaturer som granskades, och reasons listar en människoläsbar förklaring för varje identifierat problem.

Steg 5: Hantera ett dokument utan signaturer

En tom eller saknad signatures-lista är inte ett fel — den rapporteras på samma sätt som ett dokument utan något att kontrollera:

from types import SimpleNamespace
from aspose_pdf import SignaturesCompromiseDetector

unsigned_document = SimpleNamespace(signatures=[])
detector = SignaturesCompromiseDetector(unsigned_document)
result = detector.check()

print(result.compromised)  # False
print(result.reasons)      # ["unsigned document"]

Att skicka SignaturesCompromiseDetector(None) – konstruktorns standard – beter sig på samma sätt.

Vanliga problem och lösningar

compromised is False för en PDF som du vet har redigerats efter signering

SignaturesCompromiseDetector letar specifikt efter osignerade byte som lagts till efter signaturens signerade byteintervall — ett mönster som är typiskt för naiv inkrementell-uppdateringsmanipulation. Den utför inte fullständig kryptografisk signaturverifiering. För det, anropa validate() på det enskilda PdfSignature-objektet.

compromised and has_compromised_signatures verkar överflödigt

De har samma värde: compromised är en beräknad egenskap som returnerar has_compromised_signatures. Använd det namn som läser bättre i din kod.

Inget undantag kastas när dokumentet saknar signatures något attribut alls

SignaturesCompromiseDetector behandlar ett dokument utan signatures-attribut, eller document=None, på samma sätt som ett osignerat dokument — check() returnerar ett resultat med has_compromised_signatures=False och reasons=["unsigned document"] snarare än att kasta ett fel.

En felaktig PdfSignature flaggas inte

check() hoppar över alla signaturer vars byte_range inte är en lista med 4 element, eller vars reference_data inte är bytes/bytearray, snarare än att kasta ett fel eller rapportera den som komprometterad. En signatur som byggts med fel struktur utesluts tyst från kontrollen, inte flaggas.

Förväxla denna detektor med signaturskapande

SignaturesCompromiseDetector och CompromiseCheckResult inspekterar endast signaturer som redan finns på ett dokument — de har ingen metod för att skapa, tillämpa eller bädda in en ny signatur.

Vanliga frågor

Vad räknas exakt som “komprometterad” här?

Meningsfulla, icke-blankstegsbitar som läggs till PDF-filen efter en signaturs signerade byteintervall — med två undantag som detektorn redan tar hänsyn till: en senare signatur eller tidsstämpel som själv täcker dessa bytes, och en inkrementell uppdatering som endast lägger till valideringsmaterial (såsom en /DSS) utan att lägga på nytt innehåll som annotationer.

Verifierar detta den kryptografiska giltigheten av signaturen själv?

Nej. SignaturesCompromiseDetector kontrollerar manipuleringsmönster kring det signerade byte-intervallet. Kryptografisk giltighet är en separat kontroll, tillgänglig via PdfSignature.validate().

Vad säger `signatures_coverage` mig?

Antalet signaturer som kontrollen faktiskt undersökte i det inlästa dokumentet — användbart för att bekräfta att detektorn såg de signaturer du förväntade dig innan du litar på ett rent resultat.

Kan jag kontrollera ett dokument med flera signaturer samtidigt?

Ja. check() itererar över varje post i signed_document.signatures och returnerar ett aggregerat CompromiseCheckResult som täcker dem alla.

Behöver jag konstruera `PdfSignature`-objekt själv i normal användning?

Nej — Steg 3:s PdfSignature-konstruktion är för att utforska detektorns beteende direkt. I ett verkligt arbetsflöde, skicka vilket objekt ditt dokumentladdningskod redan producerar, så länge det exponerar en signatures-lista av PdfSignature-formade poster.