Documentation – Classe PdfFileSignature

Python-Net: Signer des documents PDF

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade pour appliquer des signatures numériques à des documents PDF existants. En utilisant un fichier de certificat, vous pouvez signer un document par programmation, placer la signature sur une page, attribuer des métadonnées de signature et personnaliser la façon dont la signature est affichée.

Cet article présente plusieurs flux de travail de signature courants :

Créer et lier un PdfFileSignature objet au PDF d’entrée.
Configurez le certificat de signature.
Appliquez une signature numérique à la page cible.
Attribuez éventuellement un nom de signature et une apparence visible.
Enregistrez le PDF signé.

Préparer des aides de signature réutilisables

Avant d’appliquer une signature numérique à un PDF, il est utile de mettre en place un petit groupe de fonctions d’aide réutilisables. Ces aides initialisent le gestionnaire de signature, définissent la zone de signature visible, configurent le certificat et créent des objets de signature PKCS#7 réutilisables afin que les exemples de signature ci-dessous restent autonomes et plus faciles à suivre.

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as apd


DEFAULT_CERTIFICATE_PASSWORD = "Aspose2021"
DEFAULT_SIGNATURE_NAME = "Signature1"


def create_pdf_file_signature(infile):
    pdf_signature = pdf_facades.PdfFileSignature()
    pdf_signature.bind_pdf(infile)
    return pdf_signature


def create_signature_rectangle():
    return apd.Rectangle(10, 10, 200, 60)


def configure_signature_certificate(
    pdf_signature, certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    pdf_signature.set_certificate(certificate_path, certificate_password)


def create_pkcs7_signature(
    certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    signature = ap.forms.PKCS7(certificate_path, certificate_password)
    signature.reason = "Document approval"
    signature.contact_info = "qa@example.com"
    signature.location = "New York, USA"
    signature.authority = "Aspose.PDF Example"
    return signature


def create_custom_signature_appearance():
    appearance = ap.forms.SignatureCustomAppearance()
    appearance.font_family_name = "Arial"
    appearance.font_size = 10
    appearance.show_contact_info = True
    appearance.show_location = True
    appearance.show_reason = True
    return appearance

Signer un PDF avec des paramètres de certificat de base

Cette approche configure le certificat directement sur le PdfFileSignature objet. Il est utile lorsque vous souhaitez un flux de signature simple avec des métadonnées de signature standard et aucune gestion séparée des objets de signature.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_basic_parameters(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        configure_signature_certificate(pdf_signature, certificate_path)
        pdf_signature.sign(
            1,
            "Document approval",
            "qa@example.com",
            "New York, USA",
            False,
            create_signature_rectangle(),
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Signer un PDF avec un objet PKCS7

Utilisez un PKCS7 objet lorsque vous devez préparer la signature d’abord, puis la transmettre à l’appel de signature. Ce modèle vous donne plus de contrôle sur les paramètres de signature et constitue une bonne base pour des flux de travail plus avancés.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_certificate_object(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        pdf_signature.sign(1, False, create_signature_rectangle(), signature)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Signer un PDF avec une signature nommée

Si votre flux de travail de document dépend d’un nom de champ de signature prédéfini, transmettez ce nom à sign(). Cela facilite la référence à la signature ultérieurement pour la validation, le traitement ou l’intégration à un flux de travail d’approbation.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_named_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        signature.reason = "Approved by signing workflow"
        pdf_signature.sign(
            1,
            DEFAULT_SIGNATURE_NAME,
            "Approved by signing workflow",
            "qa@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Appliquer une signature visible

Vous pouvez rendre la signature visible sur la page PDF en assignant une apparence personnalisée à la PKCS7 objet. Ceci est utile lorsque le document de sortie doit afficher les détails d’approbation tels que la raison, le lieu et les coordonnées aux utilisateurs finaux.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def apply_visible_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        signature.reason = "Visible approval signature"
        signature.custom_appearance = create_custom_signature_appearance()
        pdf_signature.sign(
            1,
            "Visible approval signature",
            "qa@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: Certification PDF

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET vous permet de certifier des documents PDF en appliquant une signature au niveau du document avec PdfFileSignature. La certification est différente d’une signature d’approbation standard car elle définit les modifications, le cas échéant, autorisées après que le document a été certifié.

Cet article présente deux flux de travail de certification courants :

Certifier un PDF et autoriser le remplissage de formulaire après la certification.
Certifier un PDF et empêcher toute modification ultérieure.

Certifier un PDF pour le remplissage de formulaire

Utilisez cette approche lorsque le document doit rester certifié mais que les utilisateurs doivent toujours remplir des formulaires interactifs ou continuer à signer le fichier. Le FILLING_IN_FORMS Le niveau d\u0027autorisation permet ces modifications contrôlées tout en maintenant la certification valide.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def certify_pdf_with_mdp_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        doc_mdp_signature = create_doc_mdp_signature(
            certificate_path,
            ap.forms.DocMDPAccessPermissions.FILLING_IN_FORMS,
            reason="Certified for form filling and signing",
        )
        pdf_signature.certify(
            1,
            "Certified for form filling and signing",
            "security@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            doc_mdp_signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Appliquer une certification au niveau du document sans autoriser de modifications

Utilisez ce mode lorsque le document certifié doit rester inchangé après la certification. Le NO_CHANGES Le niveau d’autorisation convient aux PDF finalisés où toute modification ultérieure doit invalider l’état de certification.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def apply_document_level_certification(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        doc_mdp_signature = create_doc_mdp_signature(
            certificate_path,
            ap.forms.DocMDPAccessPermissions.NO_CHANGES,
            reason="Certified with no further changes allowed",
        )
        pdf_signature.certify(
            1,
            "Certified with no further changes allowed",
            "security@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            doc_mdp_signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: Révision et autorisations

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade pour travailler avec des documents PDF signés et certifiés. En plus d’ajouter des signatures, vous pouvez également inspecter les métadonnées de signature afin de comprendre combien de révisions un document contient et quels changements sont autorisés après la certification.

Cet exemple démontre trois tâches d’inspection courantes :

Obtenez le numéro de révision d’une signature existante.
Obtenez le nombre total de révisions dans un document signé.
Lire les autorisations d’accès d’un PDF certifié.

Obtenir le numéro de révision d’une signature

Utilisez cette approche lorsqu’un PDF contient déjà une ou plusieurs signatures et que vous devez identifier la révision associée à une signature spécifique. L’exemple résout le premier nom de signature disponible, puis appelle get_revision().

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_revision(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_revision = pdf_signature.get_revision(sign_name)
        print(f"Signature Revision for '{sign_name}': {signature_revision}")
    finally:
        pdf_signature.close()

Obtenir le nombre total de révisions du document

Utiliser get_total_revision() lorsque vous avez besoin de savoir combien de révisions sont stockées dans le PDF signé. Cela est utile pour vérifier si le document a subi plusieurs mises à jour après l’application de la signature d’origine.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_total_document_revisions(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        total_revisions = pdf_signature.get_total_revision()
        print(f"Total Document Revisions: {total_revisions}")
    finally:
        pdf_signature.close()

Obtenir les autorisations d’accès d’un PDF certifié

Les documents certifiés peuvent définir quels changements sont autorisés après la certification. Utilisez get_access_permissions() pour inspecter ce niveau d’autorisation et déterminer si le document autorise aucune modification, le remplissage de formulaires ou d’autres modifications contrôlées.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_access_permissions(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        access_permissions = pdf_signature.get_access_permissions()
        print(f"Access Permissions: {access_permissions}")
    finally:
        pdf_signature.close()

Python-Net: Extraction de signature

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade pour inspecter et extraire des données à partir de documents PDF signés. Après qu’un PDF a été signé, vous pouvez l’utiliser pour exporter les ressources de signature telles que l’image visuelle de la signature et le certificat associé à la signature.

Cet exemple illustre deux tâches d’extraction courantes:

Extraire l’image visuelle associée à une signature.
Extraire le certificat de signature d’un PDF signé.

Extraire une image de signature

Utilisez cette méthode lorsque le PDF contient une signature visible et que vous souhaitez exporter ses données d’image. L’exemple ouvre le document signé, récupère le premier nom de signature disponible, extrait le flux d’image et l’écrit dans un fichier.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def extract_signature_image(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_image = pdf_signature.extract_image(sign_name)
        write_stream_data(signature_image, outfile)
    finally:
        pdf_signature.close()

Extraire un certificat de signature

Utiliser extract_certificate() lorsque vous avez besoin des données du certificat jointes à une signature. Ceci est utile pour l’inspection, les flux de travail de validation ou le stockage du certificat du signataire séparément du document PDF.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def extract_signature_certificate(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_certificate = pdf_signature.extract_certificate(sign_name)
        write_stream_data(signature_certificate, outfile)
    finally:
        pdf_signature.close()

Python-Net: Informations sur la signature

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade d’inspection des signatures numériques dans les documents PDF. Après qu’un document a été signé, vous pouvez l’utiliser pour lire les noms des signatures et récupérer les métadonnées telles que le nom du signataire, les coordonnées, l’heure de signature, le motif et le lieu.

Cet exemple montre quatre tâches courantes liées aux informations de signature :

Lister tous les noms de signature dans un PDF signé.
Lire les détails du signataire pour une signature sélectionnée.
Obtenez la date et l’heure de la signature.
Lisez le motif et le lieu de la signature.

Obtenez les noms des signatures

Utilisez cette méthode lorsqu’un PDF peut contenir une ou plusieurs signatures et que vous souhaitez inspecter les entrées de signature disponibles. L’exemple ouvre le document et imprime la liste renvoyée par get_sign_names().

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_names(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature_names = list_signature_names(pdf_signature)
        print(f"Signature Names: {signature_names}")
    finally:
        pdf_signature.close()

Obtenir les détails du signataire

Une fois que vous connaissez le nom de la signature, vous pouvez récupérer les métadonnées spécifiques au signataire. Cet exemple lit le nom du signataire et les informations de contact pour la première signature disponible dans le document.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signer_details(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signer_name = pdf_signature.get_signer_name(sign_name)
        contact_info = pdf_signature.get_contact_info(sign_name)
        print(
            f"Signer Details for '{sign_name}': "
            f"signer_name={signer_name}, contact_info={contact_info}"
        )
    finally:
        pdf_signature.close()

Obtenir la date et l’heure de la signature

Utiliser get_date_time() pour déterminer quand une signature spécifique a été appliquée. Ceci est utile pour l’audit et pour afficher l’historique des signatures dans les flux de travail des documents.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_date_and_time(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_date = pdf_signature.get_date_time(sign_name)
        print(f"Signature Date and Time for '{sign_name}': {signature_date}")
    finally:
        pdf_signature.close()

Obtenir la raison et l’emplacement de la signature

Les signatures numériques peuvent également stocker des métadonnées descriptives telles que la raison et l’emplacement de la signature. Cet exemple récupère les deux valeurs pour la signature sélectionnée et les imprime ensemble.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_reason_and_location(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_reason = pdf_signature.get_reason(sign_name)
        signature_location = pdf_signature.get_location(sign_name)
        print(
            f"Signature Reason and Location for '{sign_name}': "
            f"reason={signature_reason}, location={signature_location}"
        )
    finally:
        pdf_signature.close()

Python-Net: Vérifications d'intégrité de la signature

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade de validation des documents PDF signés. Après qu’un fichier a été signé, vous pouvez l’utiliser pour vérifier si la signature s’applique au document complet et si le contenu signé est toujours valide.

Cet exemple montre deux vérifications d’intégrité courantes :

Vérifiez si une signature couvre l’ensemble du document.
Validez l’intégrité du contenu PDF signé.

Vérifiez si une signature couvre l’ensemble du document

Utiliser covers_whole_document() lorsque vous devez vérifier que la signature s’applique à l’intégralité du PDF et non seulement à une partie de son contenu. L’exemple lit le premier nom de signature disponible et vérifie sa portée.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_signature_coverage(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        covers_document = pdf_signature.covers_whole_document(sign_name)
        print(f"Signature '{sign_name}' covers the whole document: {covers_document}")
    finally:
        pdf_signature.close()

Valider l’intégrité du document

Utiliser verify_signed() pour confirmer que le contenu du document signé n’a pas été altéré après l’application de la signature. Cette méthode aide à vérifier si le document reste valable pour la signature sélectionnée.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def validate_document_integrity(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        is_valid = pdf_signature.verify_signed(sign_name)
        print(f"Document integrity for '{sign_name}' is valid: {is_valid}")
    finally:
        pdf_signature.close()

Python-Net: Gestion des signatures

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature facade pour travailler avec les signatures numériques existantes dans les documents PDF. En plus de lire et de valider les signatures, vous pouvez également les supprimer lorsqu’un flux de travail nécessite la mise à jour du contenu signé ou l’effacement du champ de signature.

Cet exemple illustre deux tâches courantes de gestion des signatures :

Supprimer une signature d’un document PDF.
Supprimer une signature et nettoyer le champ de signature associé.

Supprimer une signature d’un PDF

Utiliser remove_signature() Lorsque vous souhaitez supprimer la signature sélectionnée du document tout en conservant la structure du champ de signature sous-jacente. L’exemple ouvre le PDF signé, résout le nom de la signature, la supprime et enregistre le fichier de sortie mis à jour.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_signature_from_pdf(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        pdf_signature.remove_signature(sign_name)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Supprimer une signature et nettoyer le champ

Utilisez la surcharge avec le supplémentaire True indiquez lorsque vous souhaitez supprimer la signature et également nettoyer le champ de signature associé. Cela est utile lorsque le champ ne doit pas rester dans le document après la suppression de la signature.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_signature_with_field_cleanup(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        pdf_signature.remove_signature(sign_name, True)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: Vérification de la signature

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade pour la validation de documents PDF signés. Après qu’un PDF a été signé, vous pouvez l’utiliser pour confirmer qu’une signature est valide et détecter si le document contient des entrées de signature.

Cet exemple démontre deux tâches de vérification courantes :

Vérifiez qu’une signature PDF existante est valide.
Vérifiez si un PDF contient des signatures.

Vérifier une signature PDF

Utiliser verify_signature() lorsque vous devez valider une signature spécifique dans le document. L’exemple résout le premier nom de signature disponible et vérifie si cette signature est valide.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def verify_pdf_signature(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        is_valid = pdf_signature.verify_signature(sign_name)
        print(f"Signature '{sign_name}' is valid: {is_valid}")
    finally:
        pdf_signature.close()

Vérifier si un PDF contient des signatures

Utiliser contains_signature() Lorsque vous avez simplement besoin de savoir si le PDF contient des signatures du tout. Ceci est utile comme vérification rapide avant d’exécuter une logique de vérification ou d’extraction plus détaillée.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_if_pdf_contains_signatures(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        contains_signatures = pdf_signature.contains_signature()
        print(f"PDF contains signatures: {contains_signatures}")
    finally:
        pdf_signature.close()

Python-Net: Gestion des droits d\'utilisation

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfFileSignature façade pour travailler avec des PDF signés et les paramètres de droits d'utilisation associés. Dans certains flux de travail, il peut être nécessaire d'inspecter si un document contient des droits d'utilisation et de les supprimer avant d'enregistrer une version mise à jour du fichier.

Cet exemple illustre une tâche courante de gestion des droits d'utilisation :

Vérifiez si un PDF contient des droits d’utilisation.
Supprimez les droits d’utilisation du document.
Enregistrez le fichier PDF mis à jour.

Vérifiez si le PDF contient des droits d’utilisation

Avant de supprimer les droits d’utilisation, l’exemple vérifie l’état actuel du document en appelant contains_usage_rights(). Cela vous permet de confirmer si les droits d’utilisation sont présents avant d’apporter des modifications.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_usage_rights(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        had_usage_rights = pdf_signature.contains_usage_rights()
        print(f"PDF contains usage rights: {had_usage_rights}")
    finally:
        pdf_signature.close()

Supprimer les droits d’utilisation du PDF

Utiliser remove_usage_rights() lorsque le document ne doit plus conserver ses paramètres de droits d’utilisation existants. L’exemple vérifie l’état initial, supprime les droits et enregistre le PDF mis à jour dans un nouveau fichier.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_usage_rights(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        had_usage_rights = pdf_signature.contains_usage_rights()
        print(f"PDF contains usage rights before removal: {had_usage_rights}")
        pdf_signature.remove_usage_rights()
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()