Hoe PDF-beveiligingshandtekeningen toe te voegen in Python

Aspose.PDF FOSS voor Python bevat een detector voor handtekeningcompromissen die een reeds ondertekende PDF controleert op een specifiek manipulatiepatroon: betekenisvolle bytes die worden toegevoegd na het ondertekende byte-bereik van een handtekening, een risico dat uniek is voor incrementeel bijgewerkte PDF-bestanden. Deze gids voegt die controle toe aan een Python-workflow met behulp van de klassen SignaturesCompromiseDetector en CompromiseCheckResult. Het maken of toepassen van nieuwe digitale handtekeningen is een apart onderdeel van de bibliotheek en wordt hier niet behandeld. De bibliotheek wordt geïnstalleerd met de onderstaande opdracht.

Stapsgewijze handleiding

Stap 1: Installeer het pakket

Installeer het Aspose.PDF FOSS-pakket:

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

Verifieer de installatie door SignaturesCompromiseDetector te importeren en een bevestigingsbericht af te drukken:

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

Stap 2: Vereiste klassen importeren

from aspose_pdf import CompromiseCheckResult, SignaturesCompromiseDetector

Stap 3: Bereid een object voor dat een handtekeningenlijst blootlegt

SignaturesCompromiseDetector parseert zelf geen PDF — zijn constructor accepteert elk object dat een signatures attribuut blootlegt: een lijst van handtekeningvermeldingen, elk met valid, byte_range en reference_data. PdfSignature — een eenvoudige, direct te construeren klasse — heeft die vorm, dus het is handig om te zien hoe de controle zich gedraagt voordat je het koppelt aan je eigen documentobject:

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

Vervang signed_document door je eigen documentobject zodra het een signatures lijst in dezelfde vorm blootlegt — elk object met dat attribuut werkt.

Stap 4: Voer de compromiscontrole uit

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() doorloopt elke handtekening in signed_document.signatures, op zoek naar niet-ondertekende inhoud die is toegevoegd na het ondertekende bytebereik van elke handtekening. Een CompromiseCheckResult vat het resultaat samen: compromised en has_compromised_signatures geven dezelfde boolean onder twee namen weer, signatures_coverage meldt hoeveel handtekeningen zijn onderzocht, en reasons geeft een menselijk leesbare uitleg voor elk gevonden probleem.

Stap 5: Verwerk een document zonder handtekeningen

Een lege of ontbrekende signatures lijst is geen foutconditie — deze wordt op dezelfde manier gerapporteerd als een document zonder iets om te controleren:

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"]

Het doorgeven van SignaturesCompromiseDetector(None) — de standaardwaarde van de constructor — gedraagt zich op dezelfde manier.

Veelvoorkomende problemen en oplossingen

compromised is False voor een PDF waarvan je weet dat deze na ondertekening is bewerkt

SignaturesCompromiseDetector zoekt specifiek naar niet-ondertekende bytes die na het ondertekende bytebereik van een handtekening zijn toegevoegd — een patroon dat typerend is voor naïeve incrementele update-manipulatie. Het voert geen volledige cryptografische handtekeningverificatie uit. Hiervoor roep je validate() aan op het individuele PdfSignature object.

compromised and has_compromised_signatures lijken overbodig

Ze hebben dezelfde waarde: compromised is een berekende eigenschap die has_compromised_signatures retourneert. Gebruik de naam die beter leesbaar is in je code.

Er wordt geen uitzondering opgegooid wanneer het document geen signatures attribuut überhaupt

SignaturesCompromiseDetector behandelt een document zonder signatures attribuut, of document=None, op dezelfde manier als een niet-ondertekend document — check() geeft een resultaat terug met has_compromised_signatures=False en reasons=["unsigned document"] in plaats van een fout te genereren.

Een misvormde PdfSignature wordt niet gemarkeerd

check() slaat elke handtekening over waarvan de byte_range geen 4-elementenlijst is, of waarvan de reference_data niet bytes/bytearray is, in plaats van een fout te genereren of deze als gecompromitteerd te melden. Een handtekening met de verkeerde vorm wordt stilletjes uitgesloten van de controle, niet gemarkeerd.

Deze detector verwarren met het aanmaken van handtekeningen

SignaturesCompromiseDetector en CompromiseCheckResult inspecteren alleen handtekeningen die al op een document bestaan — ze hebben geen methode om een nieuwe handtekening te maken, toe te passen of in te sluiten.

Veelgestelde vragen

Wat wordt hier precies beschouwd als “gecompromitteerd”?

Betekenisvolle, niet-witruimte-bytes die aan de PDF worden toegevoegd na het ondertekende byte-bereik van een handtekening — met twee uitzonderingen die de detector al in overweging neemt: een latere handtekening of tijdstempel die die bytes zelf dekt, en een incrementele update die alleen validatiemateriaal toevoegt (zoals een /DSS) zonder nieuwe inhoud zoals annotaties toe te voegen.

Verifieert dit de cryptografische geldigheid van de handtekening zelf?

Nee. SignaturesCompromiseDetector controleert op manipulatiepatronen rond het ondertekende bytebereik. Cryptografische geldigheid is een aparte controle, beschikbaar via PdfSignature.validate().

Wat vertelt `signatures_coverage` me?

Het aantal handtekeningen dat de controle daadwerkelijk heeft onderzocht in het meegegeven document — handig om te bevestigen dat de detector de verwachte handtekeningen heeft gezien voordat je een schoon resultaat vertrouwt.

Kan ik een document met meerdere handtekeningen tegelijk controleren?

Ja. check() doorloopt elke invoer in signed_document.signatures en retourneert één samengevoegde CompromiseCheckResult die ze allemaal omvat.

Moet ik in normaal gebruik zelf `PdfSignature`-objecten construeren?

Nee — de constructie van PdfSignature in stap 3 is bedoeld om het gedrag van de detector direct te verkennen. In een echte workflow geef je het object door dat jouw documentlaadcode al produceert, zolang het een signatures-lijst van PdfSignature-vormige items blootlegt.