Documentation – Proteger e Assinar Arquivos PDF em Python

Python-Net: Adicionar assinatura digital ou assinar PDF digitalmente em Python

Mon, 18 May 2026 00:00:00 +0000

Assinar PDF com assinaturas digitais

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)

A assinatura PKCS#7 destacada adiciona uma assinatura digital a um documento sem incorporar o conteúdo ao bloco de assinatura.

Use estes exemplos quando precisar aplicar assinaturas baseadas em certificado a arquivos PDF, verificar a validade da assinatura ou adicionar carimbos de tempo confiáveis a documentos assinados.

O próximo exemplo assina um documento PDF usando uma assinatura digital PKCS#7 destacada, aplicando a assinatura à primeira página em uma área retangular 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 as assinaturas digitais em um documento PDF

Cria uma instância de PdfFileSignature que permite interagir com assinaturas em PDF.
Obtenha uma lista de nomes de assinatura get_signature_names(True).
Verifica a primeira assinatura na lista verify_signature para conformidade com o 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 uma assinatura com um arquivo de certificado de chave 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 uma assinatura com o certificado extraído do arquivo

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 assinaturas com validação de cadeia 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}")

Adicionar carimbo de tempo à assinatura digital

Como assinar digitalmente um PDF com carimbo de tempo

Aspose.PDF for Python suporta assinar digitalmente o PDF com um servidor de timestamp ou serviço Web.

Para atender a esse requisito, o Configurações de Carimbo de Tempo classe foi adicionada ao namespace Aspose.PDF. Por favor, dê uma olhada no trecho de código a seguir que obtém o timestamp e o adiciona ao 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)

Assinando documentos PDF usando ECDSA

Assinar documentos PDF usando ECDSA (Algoritmo de Assinatura Digital de Curva Elíptica) envolve a utilização de criptografia de curva elíptica para gerar assinaturas digitais.

O trecho de código acima ilustra como aplicar uma assinatura digital PKCS#7 destacada a um documento PDF usando Aspose.PDF for Python. Ao carregar o documento, configurar a aparência da assinatura e as configurações de segurança, e salvar o resultado, este exemplo demonstra um fluxo de trabalho completo e confiável para assinar digitalmente arquivos PDF.

Este método garante a autenticidade e integridade do documento ao incorporar uma assinatura segura e verificável na primeira página. O uso do SHA-256 como algoritmo de digestão atende aos padrões criptográficos modernos, enquanto a capacidade de controlar a colocação da assinatura oferece flexibilidade para marcas de aprovação visíveis.

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 assinaturas ECDSA em um 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")

Tópicos de Segurança Relacionados

Python-Net: Extrair informações da assinatura de PDF em Python

Mon, 18 May 2026 00:00:00 +0000

Extrair Imagem de um Campo de Assinatura

Aspose.PDF for Python via .NET permite que você recupere a imagem visual incorporada em um Campo de Assinatura. Isto é útil quando você precisa exibir ou arquivar a aparência da assinatura sem renderizar o PDF completo.

O exemplo abaixo itera sobre todos os campos de formulário, encontra cada SignatureField, e salva sua imagem como um arquivo 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)

Ler detalhes do algoritmo de assinatura

Usar PdfFileSignature.get_signatures_info() para ler metadados criptográficos de cada assinatura em um documento — incluindo o algoritmo de digestão, o tipo de algoritmo, o padrão criptográfico e o nome da assinatura:

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)

Extrair um Certificado Digital de um Campo de Assinatura

Use o extract_certificate método em um SignatureField para recuperar o certificado incorporado como um fluxo de bytes e salvá-lo no disco para validação 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

Extrair Certificados Usando a Fachada PdfFileSignature

PdfFileSignature.try_extract_certificate() fornece uma maneira alternativa de recuperar certificados pelo nome da assinatura. O exemplo a seguir itera sobre todos os nomes de assinatura e tenta a extração para cada um:

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 Assinaturas Digitais Externas

Para confirmar que um documento não foi modificado após a assinatura, verifique cada assinatura externa usando PdfFileSignature.verify_signature(). O exemplo abaixo gera uma exceção para qualquer assinatura que falhar na verificação:

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 assinaturas comprometidas

SignaturesCompromiseDetector verifica se alguma assinatura digital em um documento foi invalidada por alterações subsequentes. Use isso em fluxos de trabalho jurídicos, financeiros ou de conformidade onde a integridade do documento deve ser garantida.

O exemplo abaixo verifica assinaturas comprometidas e relata seus nomes juntamente com a cobertura geral de assinaturas do 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)

Tópicos de Segurança Relacionados

Python-Net: Assinar documentos PDF de um Cartão Inteligente em Python

Mon, 18 May 2026 00:00:00 +0000

Aspose.PDF oferece recursos robustos para integrar componentes de assinatura visual e criptográfica, garantindo tanto a autenticidade quanto a apresentação profissional em documentos PDF assinados digitalmente.

Use este fluxo de trabalho quando seu processo de assinatura depender de certificados armazenados em dispositivos com suporte de hardware, como smart cards, tokens USB ou repositórios de certificados gerenciados.

Assinar com Smart Card usando Campo de Assinatura

Este exemplo demonstra como assinar digitalmente um documento PDF usando um certificado externo com Aspose.PDF for Python e aplicar uma imagem personalizada de aparência da assinatura:

Abrindo o documento PDF.
Criando um objeto PdfFileSignature e vinculando‑o ao documento.
Recuperando um certificado digital local usando um método personalizado get_local_certificate().
Configurando um ExternalSignature com base no certificado selecionado.
Aplicando uma imagem de aparência de assinatura personalizada (por exemplo, um logotipo da empresa ou assinatura manuscrita).
Assinando digitalmente a primeira página do documento com metadados especificados (razão, contato, localização).
Salvando o documento assinado em um novo arquivo de saída.

Este método é ideal para casos em que as assinaturas precisam ser aplicadas programaticamente usando certificados externos — como tokens de hardware, armazenamentos de certificados ou provedores confiáveis — e apresentadas com um layout visual personalizado.

A seguir estão os trechos de código para assinar um documento PDF a partir de um smart card:

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 Assinaturas Digitais

Este trecho de código demonstra como verificar assinaturas digitais em um documento PDF usando Aspose.PDF for Python:

Abrindo o arquivo PDF.
Criando um ‘PdfFileSignature object’ e vinculando‑o ao documento.
Recuperando a lista de todos os nomes de campos de assinatura usando ‘get_signature_names()’.
Iterando por cada assinatura e verificando sua validade com ‘verify_signature()’.
Lançando uma exceção se alguma assinatura falhar na verificação.

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

Assinar com Certificado Externo

Este trecho de código demonstra como adicionar e assinar um campo de assinatura digital em um documento PDF usando Aspose.PDF for Python com um certificado externo:

Abrindo o arquivo PDF como um fluxo binário.
Criando um SignatureField e posicionando‑o na primeira página do documento em uma posição especificada.
Recuperando um certificado digital local usando um método personalizado get_local_certificate().
Configurando um ExternalSignature com metadados como autoridade, motivo e informações de contato.
Atribuindo um nome de campo exclusivo ao campo de assinatura (partial_name = “sig1”).
Adicionando o campo de assinatura aos campos de formulário do PDF.
Assinando o campo com o certificado externo.
Salvando o documento assinado em um arquivo de saída.

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)

Tópicos de Segurança Relacionados

Python-Net: Criptografar e Decifrar Arquivos PDF em Python

Mon, 18 May 2026 00:00:00 +0000

Gerenciar a segurança de documentos é essencial ao trabalhar com conteúdo sensível ou crítico para os negócios. Aspose.PDF for Python via .NET fornece uma API robusta para aplicar criptografia programaticamente, controlar o acesso por meio de permissões e descriptografar arquivos PDF protegidos.

Este artigo orienta desenvolvedores Python através de exemplos práticos para definir privilégios, aplicar e remover criptografia, alterar senhas e detectar estados de proteção — tudo dentro de um fluxo de trabalho PDF.

Aspose.PDF for Python via .NET oferece aos desenvolvedores controle total sobre a segurança de PDF:

Definir privilégios - Controle de acesso refinado usando permissões. Criptografar Arquivo - Aplicar criptografia AES ou RC4 com senhas personalizadas. Descriptografar Arquivo - Remover a segurança usando a senha do proprietário. Alterar senhas - Rotacione ou atualize credenciais sem alterar o conteúdo. Inspecionar Segurança - Detectar o status de criptografia ou tipos de senha necessários.

Use esta página quando precisar proteger documentos PDF com senhas, restringir impressão ou cópia, girar credenciais ou verificar se um documento está criptografado.

Definir privilégios em um arquivo PDF existente

Você pode restringir ou permitir operações específicas (por exemplo, impressão, cópia, preenchimento de formulários) atribuindo senhas de usuário e de proprietário juntamente com privilégios de acesso.

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)

Criptografar arquivo PDF usando diferentes tipos e algoritmos de criptografia

Criptografar um PDF garante que somente usuários com credenciais válidas possam abrir ou modificar o arquivo.

Termos-chave:

Senha do usuário. Necessária para abrir o documento.
Senha do proprietário. Necessária para alterar permissões ou remover a criptografia.
Tamanho da Chave. Use AE_SX128 para máxima segurança em fluxos de trabalho modernos.

O trecho de código a seguir mostra como criptografar arquivos 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)

Descriptografar arquivo PDF usando a senha do proprietário

Para remover a proteção por senha e restaurar o acesso total:

Carrega o PDF criptografado usando a senha correta (‘password’ é a senha de usuário ou de proprietário).
Remove toda a proteção por senha e as configurações de criptografia do documento.
Salva o PDF agora desprotegido no arquivo de saída 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)

Criptografar e descriptografar um PDF com certificados de chave 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"))

Alterar senha de um arquivo PDF

Atualizar as credenciais de segurança (senhas de usuário e proprietário) de um documento PDF enquanto preserva seu conteúdo e estrutura.

Abre o PDF usando a senha de proprietário existente (‘owner’), que fornece acesso total, incluindo permissão para alterar as configurações de segurança.
Substitui as senhas antigas por uma nova senha de usuário (’newuser’) e uma nova senha de proprietário (’newowner’).
Salva o PDF com as configurações de senha atualizadas.

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)

Como - determinar se o PDF de origem está protegido por senha

Determinar a senha correta a partir de um Array

Em alguns cenários, pode ser necessário identificar a senha correta a partir de uma lista de candidatos potenciais para acessar um PDF protegido. O trecho de código abaixo demonstra como verificar se um arquivo PDF está protegido por senha e, em seguida, tentar desbloqueá‑lo iterando sobre uma lista predefinida de senhas usando Aspose.PDF for Python via .NET.

O processo inclui:

Usando PdfFileInfo para detectar se o PDF está criptografado.
Tenta abrir o PDF com cada senha usando ap.Document().
Se for bem-sucedido, ele imprime o número de páginas.
Caso contrário, ele captura a exceção e relata a senha falhada.

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