Documentation – Clase PdfFileSignature

Python-Net: Firmar documentos PDF

Tue, 14 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona la PdfFileSignature fachada para aplicar firmas digitales a documentos PDF existentes. Usando un archivo de certificado, puedes firmar un documento programáticamente, colocar la firma en una página, asignar metadatos de la firma y personalizar cómo se muestra la firma.

Este artículo demuestra varios flujos de trabajo de firma comunes:

Crear y vincular un PdfFileSignature objeto al PDF de entrada.
Configure el certificado de firma.
Aplique una firma digital a la página objetivo.
Opcionalmente asigne un nombre de firma y una apariencia visible.
Guarde el PDF firmado.

Preparar auxiliares reutilizables de firma

Antes de aplicar una firma digital a un PDF, es útil configurar un pequeño conjunto de funciones auxiliares reutilizables. Estas ayudas inicializan el manejador de firmas, definen el área visible de la firma, configuran el certificado y crean objetos de firma PKCS#7 reutilizables, de modo que los ejemplos de firma a continuación sean autocontenidos y más fáciles de seguir.

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

Firmar un PDF con parámetros de certificado básicos

Este enfoque configura el certificado directamente en el PdfFileSignature objeto. Es útil cuando deseas un flujo de firma sencillo con metadatos de firma estándar y sin una gestión separada del objeto de firma.

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

Firmar un PDF con un objeto PKCS7

Usa un PKCS7 objeto cuando necesita preparar la firma primero y luego pasarla a la llamada de firma. Este patrón le brinda más control sobre la configuración de la firma y es una buena base para flujos de trabajo más avanzados.

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

Firmar un PDF con una firma nombrada

Si el flujo de trabajo de su documento depende de un nombre de campo de firma predefinido, pase ese nombre a sign(). Esto hace que sea más fácil referenciar la firma más tarde para validación, procesamiento o integración con un flujo de aprobación.

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

Aplicar una firma visible

Puede hacer que la firma sea visible en la página PDF asignando una apariencia personalizada al PKCS7 objeto. Esto es útil cuando el documento de salida debe mostrar detalles de aprobación, como la razón, la ubicación y la información de contacto a los usuarios finales.

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: Certificación PDF

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET le permite certificar documentos PDF aplicando una firma a nivel de documento con PdfFileSignature. La certificación es diferente de una firma de aprobación estándar porque define qué cambios, si los hay, están permitidos después de que el documento ha sido certificado.

Este artículo muestra dos flujos de trabajo de certificación comunes:

Certificar un PDF y permitir el relleno de formularios después de la certificación.
Certificar un PDF y evitar cualquier cambio posterior.

Certificar un PDF para rellenar formularios

Utilice este enfoque cuando el documento deba permanecer certificado pero los usuarios aún necesiten completar formularios interactivos o continuar firmando el archivo. El FILLING_IN_FORMS El nivel de permiso permite esos cambios controlados mientras se mantiene la certificación válida.

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

Aplicar certificación a nivel de documento sin permitir cambios

Utilice este modo cuando el documento certificado debe permanecer sin cambios después de la certificación. El NO_CHANGES el nivel de permiso es apropiado para PDFs finalizados donde cualquier modificación posterior debería invalidar el estado de certificación.

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: Revisión y Permisos

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona la PdfFileSignature fachada para trabajar con documentos PDF firmados y certificados. Además de agregar firmas, también puedes inspeccionar los metadatos de la firma para entender cuántas revisiones contiene un documento y qué cambios están permitidos después de la certificación.

Este ejemplo demuestra tres tareas comunes de inspección:

Obtener el número de revisión de una firma existente.
Obtener el número total de revisiones en un documento firmado.
Lea los permisos de acceso de un PDF certificado.

Obtenga el número de revisión de una firma

Utilice este enfoque cuando un PDF ya contiene una o más firmas y necesite identificar la revisión asociada a una firma específica. El ejemplo resuelve el primer nombre de firma disponible y luego llama 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()

Obtener el número total de revisiones del documento

Usar get_total_revision() cuando necesitas saber cuántas revisiones se almacenan en el PDF firmado. Esto es útil para comprobar si el documento ha pasado por múltiples actualizaciones después de que se aplicó la firma original.

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

Obtener permisos de acceso de un PDF certificado

Los documentos certificados pueden definir qué cambios están permitidos después de la certificación. Usar get_access_permissions() para inspeccionar ese nivel de permiso y determinar si el documento permite no realizar cambios, rellenar formularios u otras modificaciones controladas.

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: Extracción de firma

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona el PdfFileSignature fachada para inspeccionar y extraer datos de documentos PDF firmados. Después de que un PDF ha sido firmado, puedes usarla para exportar recursos de firma como la imagen de firma visual y el certificado asociado a la firma.

Este ejemplo demuestra dos tareas comunes de extracción:

Extraer la imagen visual asociada a una firma.
Extraer el certificado de firma de un PDF firmado.

Extraer una imagen de firma

Utiliza este método cuando el PDF contiene una firma visible y deseas exportar sus datos de imagen. El ejemplo abre el documento firmado, obtiene el primer nombre de firma disponible, extrae el flujo de la imagen y lo escribe en un archivo.

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

Extraer un certificado de firma

Usar extract_certificate() cuando necesites los datos del certificado adjuntos a una firma. Esto es útil para inspección, flujos de trabajo de validación o para almacenar el certificado del firmante por separado del documento 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: Informacion de firmas

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona la fachada PdfFileSignature para inspeccionar firmas digitales en documentos PDF. Despues de que un documento se ha firmado, puede usarla para leer los nombres de las firmas y recuperar metadatos como el nombre del firmante, la informacion de contacto, la hora de firma, el motivo y la ubicacion.

Este ejemplo demuestra cuatro tareas comunes de informacion de firmas:

Listar todos los nombres de firma en un PDF firmado.
Leer los detalles del firmante para una firma seleccionada.
Obtener la fecha y hora de firma.
Leer el motivo y la ubicacion de la firma.

Obtener nombres de firmas

Use este metodo cuando un PDF pueda contener una o varias firmas y desee inspeccionar que entradas de firma estan disponibles. El ejemplo abre el documento e imprime la lista devuelta por 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()

Obtener detalles del firmante

Una vez que conoce el nombre de la firma, puede recuperar metadatos especificos del firmante. Este ejemplo lee el nombre del firmante y la informacion de contacto para la primera firma disponible en el documento.

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

Obtener la fecha y hora de la firma

Use get_date_time() para determinar cuando se aplico una firma especifica. Esto resulta util para auditorias y para mostrar el historial de firmas en flujos de trabajo de documentos.

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

Obtener el motivo y la ubicacion de la firma

Las firmas digitales tambien pueden almacenar metadatos descriptivos, como el motivo y la ubicacion de la firma. Este ejemplo recupera ambos valores para la firma seleccionada y los imprime juntos.

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: Comprobaciones de Integridad de Firma

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona el PdfFileSignature fachada para validar documentos PDF firmados. Después de que un archivo ha sido firmado, puedes usarla para comprobar si la firma se aplica al documento completo y si el contenido firmado sigue siendo válido.

Este ejemplo muestra dos comprobaciones de integridad comunes:

Comprueba si una firma cubre todo el documento.
Valida la integridad del contenido PDF firmado.

Comprueba si una firma cubre todo el documento

Usar covers_whole_document() cuando necesita confirmar que la firma se aplica a todo el PDF y no solo a una parte de su contenido. El ejemplo lee el primer nombre de firma disponible y verifica su cobertura.

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

Validar la integridad del documento

Usar verify_signed() para confirmar que el contenido del documento firmado no ha sido alterado después de que se aplicó la firma. Este método ayuda a verificar si el documento sigue siendo válido para la firma seleccionada.

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: Administracion de firmas

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona la fachada PdfFileSignature para trabajar con firmas digitales existentes en documentos PDF. Ademas de leer y validar firmas, tambien puede quitarlas cuando un flujo de trabajo requiere actualizar el contenido firmado o limpiar el campo de firma.

Este ejemplo demuestra dos tareas comunes de administracion de firmas:

Quitar una firma de un documento PDF.
Quitar una firma y limpiar el campo de firma asociado.

Quitar una firma de un PDF

Use remove_signature() cuando desee eliminar la firma seleccionada del documento y conservar la estructura del campo de firma subyacente. El ejemplo abre el PDF firmado, resuelve el nombre de la firma, la quita y guarda el archivo de salida actualizado.

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

Quitar una firma y limpiar el campo

Use la sobrecarga con el indicador adicional True cuando desee quitar la firma y tambien limpiar el campo de firma relacionado. Esto es util cuando el campo no debe permanecer en el documento despues de que la firma se haya eliminado.

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: Verificación de firmas

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona el PdfFileSignature fachada para validar documentos PDF firmados. Después de que un PDF ha sido firmado, puede usarla para confirmar que una firma es válida y detectar si el documento contiene entradas de firmas.

Este ejemplo muestra dos tareas comunes de verificación:

Verifique que una firma existente de PDF sea válida.
Compruebe si un PDF contiene alguna firma.

Verificar una firma de PDF

Usar verify_signature() cuando necesitas validar una firma específica en el documento. El ejemplo resuelve el primer nombre de firma disponible y verifica si esa firma es válida.

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

Verifique si un PDF contiene firmas

Usar contains_signature() cuando solo necesitas saber si el PDF incluye alguna firma. Esto es útil como una verificación rápida antes de ejecutar una lógica de verificación o extracción más detallada.

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: Administracion de derechos de uso

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET proporciona la fachada PdfFileSignature para trabajar con PDF firmados y configuraciones relacionadas de derechos de uso. En algunos flujos de trabajo, puede que necesite inspeccionar si un documento contiene derechos de uso y quitarlos antes de guardar una version actualizada del archivo.

Este ejemplo demuestra una tarea comun de administracion de derechos de uso:

Comprobar si un PDF contiene derechos de uso.
Quitar los derechos de uso del documento.
Guardar el archivo PDF actualizado.

Comprobar si el PDF contiene derechos de uso

Antes de quitar derechos de uso, el ejemplo comprueba el estado actual del documento llamando a contains_usage_rights(). Esto le permite confirmar si los derechos de uso estan presentes antes de realizar cambios.

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

Quitar derechos de uso del PDF

Use remove_usage_rights() cuando el documento ya no deba conservar su configuracion existente de derechos de uso. El ejemplo comprueba el estado inicial, quita los derechos y guarda el PDF actualizado en un nuevo archivo.

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