Documentation – Classe PdfFileSignature

Python-Net: Assinar documentos PDF

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para aplicar assinaturas digitais a documentos PDF existentes. Usando um arquivo de certificado, você pode assinar um documento programaticamente, colocar a assinatura em uma página, atribuir metadados da assinatura e personalizar como a assinatura é exibida.

Este artigo demonstra vários fluxos de trabalho comuns de assinatura:

Criar e vincular um PdfFileSignature objeto para o PDF de entrada.
Configure o certificado de assinatura.
Aplique uma assinatura digital na página de destino.
Opcionalmente, atribua um nome de assinatura e aparência visível.
Salve o PDF assinado.

Prepare reusable signing helpers

Antes de aplicar uma assinatura digital a um PDF, é útil configurar um pequeno conjunto de funções auxiliares reutilizáveis. Essas funções inicializam o manipulador de assinatura, definem a área de assinatura visível, configuram o certificado e criam objetos de assinatura PKCS#7 reutilizáveis, de modo que os exemplos de assinatura abaixo permaneçam autocontidos e mais fáceis 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

Assine um PDF com parâmetros básicos de certificado

Esta abordagem configura o certificado diretamente no PdfFileSignature objeto. É útil quando você deseja um fluxo de assinatura direto com metadados de assinatura padrão e sem gerenciamento separado de objetos de assinatura.

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

Assinar um PDF com um objeto PKCS7

Use um PKCS7 objeto quando você precisa preparar a assinatura primeiro e então passá‑la para a chamada de assinatura. Esse padrão lhe dá mais controle sobre as configurações da assinatura e é uma boa base para fluxos de trabalho mais avançados.

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

Assine um PDF com uma assinatura nomeada

Se o fluxo de trabalho do seu documento depende de um nome de campo de assinatura predefinido, passe esse nome para sign(). Isso torna mais fácil referenciar a assinatura mais tarde para validação, processamento ou integração com um fluxo de trabalho de aprovação.

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 uma assinatura visível

Você pode tornar a assinatura visível na página PDF atribuindo uma aparência personalizada ao PKCS7 objeto. Isso é útil quando o documento de saída deve mostrar detalhes de aprovação, como o motivo, a localização e as informações de contato para os usuários finais.

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: Certificação de PDF

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

Aspose.PDF for Python via .NET permite que você certifique documentos PDF aplicando uma assinatura ao nível do documento com PdfFileSignature. A certificação é diferente de uma assinatura de aprovação padrão porque define quais alterações, se houver, são permitidas após o documento ter sido certificado.

Este artigo demonstra dois fluxos de trabalho de certificação comuns:

Certificar um PDF e permitir o preenchimento de formulários após a certificação.
Certificar um PDF e impedir quaisquer alterações adicionais.

Certificar um PDF para preenchimento de formulários

Use esta abordagem quando o documento deve permanecer certificado, mas os usuários ainda precisam completar formulários interativos ou continuar assinando o arquivo. O FILLING_IN_FORMS o nível de permissão permite essas alterações controladas mantendo a certificação 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 certificação ao nível do documento sem alterações permitidas

Use este modo quando o documento certificado deve permanecer inalterado após a certificação. O NO_CHANGES o nível de permissão é adequado para PDFs finalizados, onde qualquer modificação posterior deve invalidar o estado de certificação.

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: Revisão e Permissões

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para trabalhar com documentos PDF assinados e certificados. Além de adicionar assinaturas, você também pode inspecionar os metadados da assinatura para entender quantas revisões um documento contém e quais mudanças são permitidas após a certificação.

Este exemplo demonstra três tarefas comuns de inspeção:

Obtenha o número da revisão de uma assinatura existente.
Obtenha o número total de revisões em um documento assinado.
Leia as permissões de acesso de um PDF certificado.

Obtenha o número da revisão de uma assinatura

Use esta abordagem quando um PDF já contém uma ou mais assinaturas e você precisar identificar a revisão associada a uma assinatura específica. O exemplo resolve o primeiro nome de assinatura disponível e então chama 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()

Obtenha o número total de revisões do documento

Usar get_total_revision() quando você precisa saber quantas revisões estão armazenadas no PDF assinado. Isso é útil para verificar se o documento passou por várias atualizações após a aplicação da assinatura 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()

Obtenha permissões de acesso de um PDF certificado

Documentos certificados podem definir quais alterações são permitidas após a certificação. Use get_access_permissions() para inspecionar esse nível de permissão e determinar se o documento permite nenhuma alteração, preenchimento de formulários ou outras modificações 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: Extração de Assinatura

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para inspecionar e extrair dados de documentos PDF assinados. Após um PDF ser assinado, você pode usá-la para exportar recursos de assinatura, como a imagem visual da assinatura e o certificado associado à assinatura.

Este exemplo demonstra duas tarefas comuns de extração:

Extrair a imagem visual associada a uma assinatura.
Extrair o certificado de assinatura de um PDF assinado.

Extrair uma imagem de assinatura

Use este método quando o PDF contém uma assinatura visível e você deseja exportar os dados da imagem. O exemplo abre o documento assinado, obtém o primeiro nome de assinatura disponível, extrai o fluxo da imagem e grava‑o em um arquivo.

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

Extrair um certificado de assinatura

Usar extract_certificate() quando você precisar dos dados do certificado anexados a uma assinatura. Isso é útil para inspeção, fluxos de trabalho de validação ou para armazenar o certificado do assinante separadamente do 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: Informações da Assinatura

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para inspeção de assinaturas digitais em documentos PDF. Após um documento ter sido assinado, você pode usá-la para ler os nomes das assinaturas e recuperar metadados como o nome do assinante, informações de contato, hora da assinatura, motivo e localização.

Este exemplo demonstra quatro tarefas comuns de informações de assinatura:

Listar todos os nomes de assinatura em um PDF assinado.
Ler detalhes do assinante para uma assinatura selecionada.
Obtenha a data e hora da assinatura.
Leia o motivo e a localização da assinatura.

Obtenha nomes de assinatura

Use este método quando um PDF pode conter uma ou mais assinaturas e você deseja inspecionar quais entradas de assinatura estão disponíveis. O exemplo abre o documento e imprime a lista retornada 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()

Obter detalhes do assinante

Depois de conhecer o nome da assinatura, você pode recuperar metadados específicos do assinante. Este exemplo lê o nome do assinante e as informações de contato da primeira assinatura disponível no 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()

Obter data e hora da assinatura

Usar get_date_time() para determinar quando uma assinatura específica foi aplicada. Isso é útil para auditoria e para exibir o histórico de assinaturas nos fluxos de trabalho 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()

Obter motivo e localização da assinatura

As assinaturas digitais também podem armazenar metadados descritivos, como o motivo e a localização da assinatura. Este exemplo recupera ambos os valores para a assinatura selecionada e os 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: Verificações de Integridade de Assinatura

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para validar documentos PDF assinados. Depois que um arquivo foi assinado, você pode usá-la para verificar se a assinatura se aplica ao documento completo e se o conteúdo assinado ainda é válido.

Este exemplo demonstra duas verificações de integridade comuns:

Verifique se uma assinatura cobre todo o documento.
Valide a integridade do conteúdo PDF assinado.

Verifique se uma assinatura cobre todo o documento

Usar covers_whole_document() quando você precisa confirmar que a assinatura se aplica ao PDF completo e não apenas a parte de seu conteúdo. O exemplo lê o primeiro nome de assinatura disponível e verifica sua 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 integridade do documento

Usar verify_signed() para confirmar que o conteúdo do documento assinado não foi alterado após a aplicação da assinatura. Este método ajuda a verificar se o documento permanece válido para a assinatura selecionada.

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: Gerenciamento de Assinaturas

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para trabalhar com assinaturas digitais existentes em documentos PDF. Além de ler e validar assinaturas, você também pode removê-las quando um fluxo de trabalho requer que o conteúdo assinado seja atualizado ou que o campo de assinatura seja limpo.

Este exemplo demonstra duas tarefas comuns de gerenciamento de assinaturas:

Remova uma assinatura de um documento PDF.
Remova uma assinatura e limpe o campo de assinatura associado.

Remova uma assinatura de um PDF

Usar remove_signature() quando você deseja excluir a assinatura selecionada do documento enquanto mantém a estrutura subjacente do campo de assinatura intacta. O exemplo abre o PDF assinado, resolve o nome da assinatura, remove‑a e salva o arquivo de saída atualizado.

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

Remover uma assinatura e limpar o campo

Use a sobrecarga com o adicional True marque quando quiser remover a assinatura e também limpar o campo de assinatura relacionado. Isso é útil quando o campo não deve permanecer no documento após a assinatura ter sido excluída.

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: Verificação de Assinatura

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para validar documentos PDF assinados. Depois que um PDF foi assinado, você pode usá-lo para confirmar que uma assinatura é válida e para detectar se o documento contém entradas de assinatura.

Este exemplo demonstra duas tarefas comuns de verificação:

Verifique se uma assinatura PDF existente é válida.
Verifique se um PDF contém alguma assinatura.

Verificar uma assinatura PDF

Usar verify_signature() quando você precisa validar uma assinatura específica no documento. O exemplo resolve o primeiro nome de assinatura disponível e verifica se essa assinatura é 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()

Verificar se um PDF contém assinaturas

Usar contains_signature() quando você só precisa saber se o PDF inclui alguma assinatura. Isso é útil como uma verificação rápida antes de executar uma lógica de verificação ou extração mais detalhada.

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: Gerenciamento de Direitos de Uso

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

Aspose.PDF for Python via .NET fornece o PdfFileSignature fachada para trabalhar com PDFs assinados e configurações relacionadas de direitos de uso. Em alguns fluxos de trabalho, pode ser necessário inspecionar se um documento contém direitos de uso e removê-los antes de salvar uma versão atualizada do arquivo.

Este exemplo demonstra uma tarefa comum de gerenciamento de direitos de uso:

Verifique se um PDF contém direitos de uso.
Remova os direitos de uso do documento.
Salve o arquivo PDF atualizado.

Verifique se o PDF contém direitos de uso

Antes de remover os direitos de uso, o exemplo verifica o estado atual do documento chamando contains_usage_rights(). Isto permite confirmar se os direitos de uso estão presentes antes de fazer alterações.

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

Remover direitos de uso do PDF

Usar remove_usage_rights() quando o documento não deve mais manter as configurações de direitos de uso existentes. O exemplo verifica o estado inicial, remove os direitos e salva o PDF atualizado em um novo arquivo.

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