Documentation – Proteger y firmar archivos PDF en Python

Python-Net: Agregar firma digital o firmar digitalmente PDF en Python

Wed, 15 Apr 2026 00:00:00 +0000

Firmar PDF con firmas digitales

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def sign_document(infile: str, outfile: str, pfxfile: str) -> None:
    """Sign a PDF document with a PKCS#7 certificate."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            pkcs = ap.forms.PKCS7(pfxfile, "12345")
            signature.sign(1, True, drawing.Rectangle(300, 100, 400, 200), pkcs)
            signature.save(outfile)

Una firma PKCS#7 separada agrega una firma digital a un documento sin incrustar el contenido en el bloque de firma.

Utilice estos ejemplos cuando necesite aplicar firmas basadas en certificados a archivos PDF, verificar la validez de la firma o agregar marcas de tiempo confiables a documentos firmados.

El siguiente ejemplo firma un documento PDF usando una firma digital PKCS#7 separada, aplicando la firma a la primera página en una zona rectangular especificada.

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def sign_document_PKCS7_detached(
    infile: str,
    outfile: str,
    pfxfile: str,
    password: str,
) -> None:
    """Sign a PDF document with a detached PKCS#7 certificate."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            pkcs = ap.forms.PKCS7Detached(
                pfxfile,
                password,
                ap.DigestHashAlgorithm.SHA256,
            )
            signature.sign(1, True, drawing.Rectangle(300, 100, 400, 200), pkcs)
            signature.save(outfile)

Verificar todas las firmas digitales en un documento PDF

Crea una instancia de PdfFileSignature que le permite interactuar con firmas en PDF.
Obtener una lista de nombres de firma get_signature_names(True).
Comprueba la primera firma en la lista verify_signature para el cumplimiento del certificado especificado.

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify(infile: str) -> None:
    """Verify all digital signatures in a PDF document."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            for signature_name in signature.get_signature_names(True):
                if not signature.verify_signature(signature_name):
                    raise Exception("Not verified")

Verificar una firma con un archivo de certificado de clave pública

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify_with_public_key_certificate1(certificate: str, infile: str) -> None:
    """Verify a signature with a public key certificate file."""
    with ap.facades.PdfFileSignature(infile) as file_sign:
        signature_names = file_sign.get_signature_names(True)
        with open(certificate, "rb") as file_stream:
            certificate_bytes = file_stream.read()
        print(file_sign.verify_signature(signature_names[0], certificate_bytes))

Verificar una firma con el certificado extraído del archivo

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify_with_public_key_certificate_from_signature(infile: str) -> None:
    """Verify a signature with the certificate extracted from the file."""
    with ap.facades.PdfFileSignature(infile) as file_sign:
        signature_names = file_sign.get_signature_names(True)
        certificate = []
        if file_sign.try_extract_certificate(signature_names[0], certificate):
            print(file_sign.verify_signature(signature_names[0], certificate[0]))
        else:
            print(False)

Verificar firmas con validación de cadena de certificados habilitada

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify_signature_with_certificate_check(infile: str) -> None:
    """Verify signatures with certificate-chain validation enabled."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            for signature_name in signature.get_signature_names(True):
                options = ap.security.ValidationOptions()
                options.validation_mode = ap.security.ValidationMode.STRICT
                options.validation_method = ap.security.ValidationMethod.AUTO
                options.check_certificate_chain = True
                options.request_timeout = 20000
                validation_result = []
                verified = signature.verify_signature(
                    signature_name,
                    options,
                    validation_result,
                )
                print(f"Certificate validation result: {validation_result[0].status}")
                print(f"Is verified: {verified}")

Agregar marca de tiempo a la firma digital

Cómo firmar digitalmente un PDF con sello de tiempo

Aspose.PDF for Python permite firmar digitalmente el PDF con un servidor de marca de tiempo o un servicio web.

Para cumplir con este requisito, el Configuración de marca de tiempo Se ha añadido una clase al espacio de nombres Aspose.PDF. Por favor, consulte el siguiente fragmento de código que obtiene la marca de tiempo y la añade al documento PDF:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def sign_with_time_stamp_server(
    infile: str,
    outfile: str,
    pfxfile: str,
    password: str,
) -> None:
    """Sign a PDF document and apply a timestamp from an external server."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            pkcs = ap.forms.PKCS7(pfxfile, password)
            pkcs.timestamp_settings = ap.TimestampSettings(
                "https://freetsa.org/tsr",
                "",
                ap.DigestHashAlgorithm.SHA256,
            )
            rect = drawing.Rectangle(100, 100, 200, 100)
            signature.sign(
                1, "Signature Reason", "Contact", "Location", True, rect, pkcs
            )
            signature.save(outfile)

Firmar documentos PDF usando ECDSA

Firmar documentos PDF usando ECDSA (Elliptic Curve Digital Signature Algorithm) implica utilizar criptografía de curva elíptica para generar firmas digitales.

El fragmento de código anterior ilustra cómo aplicar una firma digital PKCS#7 separada a un documento PDF usando Aspose.PDF for Python. Al cargar el documento, configurar la apariencia de la firma y los ajustes de seguridad, y guardar el resultado, este ejemplo demuestra un flujo de trabajo completo y fiable para firmar digitalmente archivos PDF.

Este método garantiza la autenticidad e integridad del documento al incrustar una firma segura y verificable en la primera página. El uso de SHA-256 como algoritmo de resumen cumple con los estándares criptográficos modernos, mientras que la capacidad de controlar la ubicación de la firma ofrece flexibilidad para marcas de aprobación visibles.

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def sign_ecdsa(infile: str, outfile: str, pfxfile: str, password: str) -> None:
    """Sign a PDF document with an ECDSA signature."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            pkcs = ap.forms.PKCS7Detached(
                pfxfile,
                password,
                ap.DigestHashAlgorithm.SHA256,
            )
            signature.sign(1, True, drawing.Rectangle(300, 100, 400, 200), pkcs)
            signature.save(outfile)

Verificar firmas ECDSA en un documento PDF

def verify_ecdsa(infile: str) -> None:
    """Verify ECDSA signatures in a PDF document."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            if not signature.contains_signature():
                raise Exception("Not contains signature")

            for signature_name in signature.get_signature_names(True):
                if not signature.verify_signature(signature_name):
                    raise Exception("Not verified")

Temas de Seguridad Relacionados

Python-Net: Extraer información de la firma del PDF en Python

Wed, 15 Apr 2026 00:00:00 +0000

Extraer imagen de un campo de firma

Aspose.PDF for Python via .NET le permite recuperar la imagen visual incrustada en un CampoDeFirma. Esto es útil cuando necesitas mostrar o archivar la apariencia de la firma sin renderizar el PDF completo.

El ejemplo a continuación itera sobre todos los campos de formulario, encontrando cada uno SignatureField, y guarda su imagen como un archivo JPEG:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def extract_images_from_signature_field(infile: str, outfile: str) -> None:
    """Extract the image stored in a signature field."""
    with ap.Document(infile) as document:
        for field in document.form:
            if not isinstance(field, ap.forms.SignatureField):
                continue

            image_stream = field.extract_image()
            if image_stream is None:
                continue

            image = drawing.Bitmap.from_stream(image_stream)
            image.save(outfile, drawing.imaging.ImageFormat.jpeg)

Leer detalles del algoritmo de firma

Usar PdfFileSignature.get_signatures_info() leer los metadatos criptográficos de cada firma en un documento — incluyendo el algoritmo de resumen, el tipo de algoritmo, la norma criptográfica y el nombre de la firma:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def get_signatures_info(infile: str) -> None:
    """Print information about all signatures in a PDF document."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as signature:
            for signature_info in signature.get_signatures_info():
                print(signature_info.DIGEST_HASH_ALGORITHM)
                print(signature_info.ALGORITHM_TYPE)
                print(signature_info.CRYPTOGRAPHIC_STANDARD)
                print(signature_info.signature_name)

Extraer un certificado digital de un campo de firma

Usa el extract_certificate método en un SignatureField para recuperar el certificado incrustado como un flujo de bytes y guardarlo en disco para validación externa:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def extract_certificate(infile: str, outfile: str) -> None:
    """Extract a certificate from a signature field and save it to disk."""
    with ap.Document(infile, password="owner") as document:
        for field in document.form:
            if not isinstance(field, ap.forms.SignatureField):
                continue

            certificate_stream = field.extract_certificate()
            if certificate_stream is None:
                continue

            with certificate_stream:
                bytes_data = bytearray(certificate_stream.length)
                certificate_stream.read(bytes_data, 0, len(bytes_data))
                with open(outfile, "wb") as file_stream:
                    file_stream.write(bytes_data)
                return

Extraer certificados usando la fachada PdfFileSignature

PdfFileSignature.try_extract_certificate() proporciona una forma alternativa de obtener certificados por nombre de firma. El siguiente ejemplo itera sobre todos los nombres de firma e intenta la extracción para cada uno:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def extract_certificate_try_extract_certificate_method(infile: str) -> None:
    """Extract certificates with the try_extract_certificate facade method."""
    with ap.Document(infile, password="owner") as document:
        with ap.facades.PdfFileSignature(document) as signature:
            for signature_name in signature.get_signature_names(True):
                certificate = []
                if signature.try_extract_certificate(signature_name, certificate):
                    print("The certificate extraction succeeded")

Verificar firmas digitales externas

Para confirmar que un documento no ha sido modificado después de firmarlo, verifique cada firma externa usando PdfFileSignature.verify_signature(). El ejemplo a continuación genera una excepción para cualquier firma que falle la verificación:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify_external_signature(infile: str) -> None:
    """Verify an external signature in a PDF document."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as pdf_signature:
            for signature_name in pdf_signature.get_signature_names(True):
                if not pdf_signature.verify_signature(signature_name):
                    raise Exception("Not verified")

Detectar firmas comprometidas

SignaturesCompromiseDetector verifica si alguna firma digital en un documento ha sido invalidada por cambios posteriores. Utilízalo en flujos de trabajo legales, financieros o de cumplimiento donde se debe garantizar la integridad del documento.

El siguiente ejemplo verifica firmas comprometidas y reporta sus nombres junto con la cobertura total de firmas del documento:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def check(infile: str) -> None:
    """Check whether a PDF contains compromised signatures."""
    with ap.Document(infile) as document:
        detector = ap.SignaturesCompromiseDetector(document)
        result = []

        if detector.check(result):
            print("No signature compromise detected")
            return

        if result[0].has_compromised_signatures:
            print(
                f"Count of compromised signatures: {len(result[0].COMPROMISED_SIGNATURES)}"
            )
            for signature_name in result[0].COMPROMISED_SIGNATURES:
                print(f"Signature name: {signature_name.FULL_NAME}")

        print(result[0].signatures_coverage)

Temas de Seguridad Relacionados

Python-Net: Firmar documentos PDF desde una Smart Card en Python

Wed, 15 Apr 2026 00:00:00 +0000

Aspose.PDF ofrece capacidades robustas para integrar componentes de firma visual y criptográfica, garantizando tanto la autenticidad como una presentación profesional en documentos PDF firmados digitalmente.

Utilice este flujo de trabajo cuando su proceso de firma dependa de certificados almacenados en dispositivos con soporte de hardware, como tarjetas inteligentes, tokens USB o almacenes de certificados gestionados.

Firmar con tarjeta inteligente usando campo de firma

Este ejemplo muestra cómo firmar digitalmente un documento PDF utilizando un certificado externo con Aspose.PDF for Python y aplicar una imagen personalizada de apariencia de firma:

Abriendo el documento PDF.
Creando un objeto PdfFileSignature y vinculándolo al documento.
Recuperando un certificado digital local mediante un método personalizado get_local_certificate().
Configurando una ExternalSignature basada en el certificado seleccionado.
Aplicando una imagen de apariencia de firma personalizada (p.ej., un logotipo de la empresa o una firma manuscrita).
Firmando digitalmente la primera página del documento con metadatos especificados (razón, contacto, ubicación).
Guardando el documento firmado en un nuevo archivo de salida.

Este método es ideal para casos en los que las firmas deben aplicarse programáticamente usando certificados externos—como tokens de hardware, almacenes de certificados o proveedores de confianza—y presentarse con un diseño visual personalizado.

A continuación se muestran los fragmentos de código para firmar un documento PDF desde una tarjeta inteligente:

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def sign_with_smart_card(infile: str, outfile: str, pngfile: str) -> None:
    """Sign a PDF document using a smart-card certificate."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature() as pdf_signature:
            pdf_signature.bind_pdf(document)
            external_signature = ap.forms.ExternalSignature(get_local_certificate())
            pdf_signature.signature_appearance = pngfile
            pdf_signature.sign(
                1,
                "Reason",
                "Contact",
                "Location",
                True,
                drawing.Rectangle(100, 100, 200, 200),
                external_signature,
            )
            pdf_signature.save(outfile)

Verificar firmas digitales

Este fragmento de código muestra cómo verificar firmas digitales en un documento PDF usando Aspose.PDF for Python:

Abriendo el archivo PDF.
Crear un objeto ‘PdfFileSignature’ y vincularlo al documento.
Recuperar la lista de todos los nombres de campos de firma usando ‘get_signature_names()’.
Iterar a través de cada firma y verificar su validez con ‘verify_signature()’.
Lanzar una excepción si alguna firma no pasa la verificación.

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def verify_external_signature(infile: str) -> None:
    """Verify an external signature in a PDF document."""
    with ap.Document(infile) as document:
        with ap.facades.PdfFileSignature(document) as pdf_signature:
            for signature_name in pdf_signature.get_signature_names(True):
                if not pdf_signature.verify_signature(signature_name):
                    raise Exception("Not verified")

Firmar con certificado externo

Este fragmento de código muestra cómo agregar y firmar un campo de firma digital en un documento PDF usando Aspose.PDF for Python con un certificado externo:

Abriendo el archivo PDF como un flujo binario.
Creando un SignatureField y colocándolo en la primera página del documento en una posición especificada.
Recuperando un certificado digital local mediante un método personalizado get_local_certificate().
Configurando un ExternalSignature con metadatos como autoridad, motivo y información de contacto.
Asignando un nombre de campo único al campo de firma (partial_name = "sig1").
Agregar el campo de firma a los campos del formulario del PDF.
Firmando el campo con el certificado externo.
Guardando el documento firmado en un archivo de salida.

import sys
from os import path
import aspose.pdf as ap
import aspose.pydrawing as drawing

def get_signature_info_using_signature_field(infile: str, outfile: str) -> None:
    """Create a signature field and sign it with an external certificate."""
    with open(infile, "rb+") as file_stream:
        document = ap.Document(file_stream)
        signature_field = ap.forms.SignatureField(
            document.pages[1],
            ap.Rectangle(100, 400, 10, 10, True),
        )
        selected_certificate = get_local_certificate()
        external_signature = ap.forms.ExternalSignature(selected_certificate)
        external_signature.authority = "Me"
        external_signature.reason = "Reason"
        external_signature.contact_info = "Contact"
        signature_field.partial_name = "sig1"
        document.form.add(signature_field, 1)
        signature_field.sign(external_signature)
        document.save(outfile)

Temas de Seguridad Relacionados

Python-Net: Cifrar y descifrar archivos PDF en Python

Wed, 15 Apr 2026 00:00:00 +0000

Gestionar la seguridad de documentos es esencial al trabajar con contenido sensible o crítico para el negocio. Aspose.PDF for Python via .NET ofrece una API robusta para aplicar encriptación de forma programática, controlar el acceso mediante permisos y descifrar archivos PDF protegidos.

Este artículo guía a los desarrolladores de Python a través de ejemplos prácticos para establecer privilegios, aplicar y eliminar encriptación, cambiar contraseñas y detectar estados de protección — todo dentro de un flujo de trabajo de PDF.

Aspose.PDF for Python via .NET brinda a los desarrolladores un control total sobre la seguridad de PDF:

Establecer privilegios - Control de acceso granular mediante permisos. Cifrar archivo - Aplicar cifrado AES o RC4 con contraseñas personalizadas. Desencriptar archivo - Eliminar la seguridad usando la contraseña del propietario. Cambiar contraseñas - Rotar o actualizar credenciales sin alterar el contenido. Inspect Security - Detectar estado de cifrado o tipos de contraseña requeridos.

Utilice esta página cuando necesite proteger documentos PDF con contraseñas, restringir la impresión o la copia, rotar credenciales o inspeccionar si un documento está cifrado.

Establecer privilegios en un archivo PDF existente

Puede restringir o permitir operaciones específicas (p. ej., imprimir, copiar, rellenar formularios) asignando contraseñas de usuario y de propietario junto con privilegios de acceso.

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def set_privileges_on_existing_pdf_file(infile: str, outfile: str) -> None:
    """Set restricted privileges on an existing PDF document."""
    with ap.Document(infile) as document:
        document_privilege = ap.facades.DocumentPrivilege.forbid_all
        document_privilege.allow_screen_readers = True
        document.encrypt(
            "user",
            "owner",
            document_privilege,
            ap.CryptoAlgorithm.AESx128,
            False,
        )
        document.save(outfile)

Cifrar archivo PDF usando diferentes tipos y algoritmos de cifrado

Cifrar un PDF asegura que solo los usuarios con credenciales válidas puedan abrir o modificar el archivo.

Términos clave:

Contraseña de usuario. Requerida para abrir el documento.
Contraseña del propietario. Necesaria para cambiar permisos o eliminar el cifrado.
KeySize. Use AE_SX128 para obtener la máxima seguridad en flujos de trabajo modernos.

El siguiente fragmento de código le muestra cómo cifrar archivos PDF.

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def encrypt_pdf_file(infile: str, outfile: str) -> None:
    """Encrypt a PDF document with user and owner passwords."""
    with ap.Document(infile) as document:
        document.encrypt(
            "user",
            "owner",
            ap.Permissions.EXTRACT_CONTENT,
            ap.CryptoAlgorithm.AESx128,
        )
        document.save(outfile)

Descifrar archivo PDF usando la contraseña del propietario

Para eliminar la protección con contraseña y restaurar el acceso completo:

Carga el PDF cifrado usando la contraseña correcta (‘password’ es la contraseña de usuario o de propietario).
Elimina toda la protección con contraseña y la configuración de cifrado del documento.
Guarda el PDF ahora sin protección en el archivo de salida especificado.

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def decrypt_pdf_file(infile: str, outfile: str) -> None:
    """Decrypt a password-protected PDF document."""
    with ap.Document(infile, "password") as document:
        document.decrypt()
        document.save(outfile)

Cifrar y descifrar un PDF con certificados de clave pública

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def pub_sec_encryption(
    crypto_algorithm,
    pub_cert: str,
    in_pfx: str,
    outfile: str,
) -> None:
    """Demonstrate public-key encryption and decryption."""
    pfx_password = "12345"

    with ap.Document() as document:
        document.info.title = "TestTitle"
        document.info.author = "TestAuthor"
        page = document.pages.add()
        page.paragraphs.add(ap.text.TextFragment("Hello World!"))

        with open(pub_cert, "rb") as file_stream:
            byte_content = file_stream.read()

        document.encrypt(
            ap.Permissions.PRINT_DOCUMENT,
            crypto_algorithm,
            [byte_content],
        )
        document.save(outfile)

    with ap.Document(
        outfile,
        ap.security.CertificateEncryptionOptions(pub_cert, in_pfx, pfx_password),
    ) as document:
        print(document.info.title)
        print(document.info.author)

        text_absorber = ap.text.TextAbsorber()
        document.pages[1].accept(text_absorber)
        print(text_absorber.text)

        document.decrypt()
        document.save(path.join(path.dirname(outfile), "pubsec_decrypted_out.pdf"))

Cambiar la contraseña de un archivo PDF

Actualizar las credenciales de seguridad (contraseñas de usuario y propietario) de un documento PDF mientras se preserva su contenido y estructura.

Abre el PDF usando la contraseña de propietario existente (‘owner’), lo que brinda acceso total, incluida la autorización para cambiar la configuración de seguridad.
Reemplaza las contraseñas antiguas con una nueva contraseña de usuario (’newuser’) y una nueva contraseña de propietario (’newowner’).
Guarda el PDF con la configuración de contraseña actualizada.

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def change_password(infile: str, outfile: str) -> None:
    """Change the passwords of a password-protected PDF document."""
    with ap.Document(infile, "owner") as document:
        document.change_passwords("owner", "newuser", "newowner")
        document.save(outfile)

Cómo - determinar si el PDF de origen está protegido con contraseña

Determinar la contraseña correcta del array

En algunos escenarios, es posible que necesite identificar la contraseña correcta de una lista de candidatos potenciales para acceder a un PDF protegido. El fragmento de código a continuación demuestra cómo verificar si un archivo PDF está protegido con contraseña y luego intentar desbloquearlo iterando a través de una lista predefinida de contraseñas usando Aspose.PDF for Python via .NET.

El proceso incluye:

Usando PdfFileInfo para detectar si el PDF está encriptado.
Intenta abrir el PDF con cada contraseña usando ap.Document().
Si tiene éxito, imprime el número de páginas.
Si no, captura la excepción y reporta la contraseña fallida.

import sys
from os import path

import aspose.pdf as ap
import aspose.pydrawing as drawing

def determine_correct_password_from_array(infile: str) -> None:
    """Try a list of passwords until the document opens successfully."""
    with ap.facades.PdfFileInfo() as pdf_file_info:
        pdf_file_info.bind_pdf(infile)
        print(f"File is password protected {pdf_file_info.is_encrypted}")

    passwords = ["test", "test1", "test2", "test3", "sample"]

    for password in passwords:
        try:
            with ap.Document(infile, password) as document:
                if len(document.pages) > 0:
                    print(f"Password = {password} is correct")
                    print(f"Number of pages in document = {len(document.pages)}")
                    break
        except Exception:
            print(f"Password = {password} is not correct")