Documentation – Sécuriser et signer des fichiers PDF en Python

Python-Net: Ajouter une signature numérique ou signer numériquement un PDF en Python

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

Signer le PDF avec des signatures numériques

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)

Une signature détachée PKCS#7 ajoute une signature numérique à un document sans intégrer le contenu dans le bloc de signature.

Utilisez ces exemples lorsque vous devez appliquer des signatures basées sur des certificats aux fichiers PDF, vérifier la validité des signatures ou ajouter des horodatages de confiance aux documents signés.

L’exemple suivant signe un document PDF en utilisant une signature numérique détachée PKCS#7, appliquant la signature à la première page dans une zone rectangulaire spécifiée.

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)

Vérifier toutes les signatures numériques dans un document PDF

Crée une instance de PdfFileSignature qui vous permet d’interagir avec les signatures dans le PDF.
Obtenez une liste des noms de signature get_signature_names(True).
Vérifie la première signature de la liste verify_signature pour se conformer au certificat spécifié.

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

Vérifier une signature avec un fichier de certificat de clé publique

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

Vérifier une signature avec le certificat extrait du fichier

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)

Vérifier les signatures avec la validation de la chaîne de certificats activée

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

Ajouter un horodatage à la signature numérique

Comment signer numériquement un PDF avec horodatage

Aspose.PDF for Python prend en charge la signature numérique du PDF avec un serveur d’horodatage ou un service Web.

Afin d’accomplir cette exigence, le TimestampSettings Une classe a été ajoutée à l’espace de noms Aspose.PDF. Veuillez consulter le fragment de code suivant qui récupère l’horodatage et l’ajoute au document 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)

Signer des documents PDF en utilisant ECDSA

Signer des documents PDF en utilisant ECDSA (Elliptic Curve Digital Signature Algorithm) implique d’utiliser la cryptographie à courbes elliptiques pour générer des signatures numériques.

L’extrait de code ci‑dessus illustre comment appliquer une signature numérique détachée PKCS#7 à un document PDF en utilisant Aspose.PDF for Python. En chargeant le document, en configurant l’apparence de la signature et les paramètres de sécurité, puis en enregistrant le résultat, cet exemple démontre un flux de travail complet et fiable pour signer numériquement des fichiers PDF.

Cette méthode garantit l’authenticité et l’intégrité du document en incorporant une signature sécurisée et vérifiable sur la première page. L’utilisation de SHA-256 comme algorithme de hachage répond aux normes cryptographiques modernes, tandis que la possibilité de contrôler le placement de la signature offre une flexibilité pour les marques d’approbation 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)

Vérifier les signatures ECDSA dans un document 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")

Sujets de sécurité associés

Python-Net: Extraire les informations de signature du PDF en Python

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

Extraire l’image d’un champ de signature

Aspose.PDF for Python via .NET vous permet de récupérer l’image visuelle intégrée dans un SignatureField. Ceci est utile lorsque vous devez afficher ou archiver l’apparence de la signature sans rendre le PDF complet.

L’exemple ci-dessous parcourt tous les champs de formulaire, et trouve chacun d’eux. SignatureField, et enregistre son image sous forme de fichier 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)

Lire les détails de l’algorithme de signature

Utiliser PdfFileSignature.get_signatures_info() lire les métadonnées cryptographiques pour chaque signature d’un document — y compris l’algorithme de hachage, le type d’algorithme, la norme cryptographique et le nom de la signature :

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)

Extraire un certificat numérique d’un champ de signature

Utilisez le extract_certificate() méthode sur un SignatureField pour récupérer le certificat intégré sous forme de flux d’octets et l’enregistrer sur le disque pour une validation externe :

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

Extraire les certificats en utilisant la façade PdfFileSignature

PdfFileSignature.try_extract_certificate() fournit une méthode alternative pour récupérer les certificats par nom de signature. L’exemple suivant parcourt tous les noms de signature et tente l’extraction pour chacun :

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

Vérifier les signatures numériques externes

Pour confirmer qu’un document n’a pas été modifié après la signature, vérifiez chaque signature externe en utilisant PdfFileSignature.verify_signature(). L’exemple ci-dessous lève une exception pour toute signature qui échoue à la vérification :

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

Détecter les signatures compromises

SignaturesCompromiseDetector vérifie si des signatures numériques dans un document ont été invalidées par des modifications ultérieures. Utilisez ceci dans les flux de travail juridiques, financiers ou de conformité où l’intégrité du document doit être garantie.

L’exemple ci-dessous vérifie les signatures compromises et rapporte leurs noms ainsi que la couverture globale des signatures du document :

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)

Sujets de sécurité associés

Python-Net: Signer des documents PDF à partir d'une carte à puce en Python

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

Aspose.PDF fournit des capacités robustes pour l’intégration des composants de signature visuelle et cryptographique, garantissant à la fois l’authenticité et une présentation professionnelle dans les documents PDF signés numériquement.

Utilisez ce flux de travail lorsque votre processus de signature dépend de certificats stockés sur des appareils matériels tels que les cartes à puce, les jetons USB ou les magasins de certificats gérés.

Signer avec une carte à puce en utilisant le champ de signature

Cet exemple montre comment signer numériquement un document PDF à l’aide d’un certificat externe avec Aspose.PDF for Python et appliquer une image d’apparence de signature personnalisée :

Ouverture du document PDF.
Création d’un objet PdfFileSignature et liaison de celui-ci au document.
Récupération d’un certificat numérique local à l’aide d’une méthode personnalisée get_local_certificate().
Configuration d’une ExternalSignature basée sur le certificat sélectionné.
Appliquer une image personnalisée d’apparence de signature (par ex., un logo d’entreprise ou une signature manuscrite).
Signer numériquement la première page du document avec les métadonnées spécifiées (raison, contact, emplacement).
Enregistrer le document signé dans un nouveau fichier de sortie.

Cette méthode est idéale pour les cas où les signatures doivent être appliquées de manière programmatique à l’aide de certificats externes—tels que des jetons matériels, des magasins de certificats ou des fournisseurs de confiance—et présentées avec une mise en page visuelle personnalisée.

Voici les extraits de code pour signer un document PDF à partir d’une carte à puce :

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)

Vérifier les signatures numériques

Cet extrait de code montre comment vérifier les signatures numériques dans un document PDF en utilisant Aspose.PDF for Python:

Ouverture du fichier PDF.
Création d’un ‘PdfFileSignature object’ et liaison au document.
Récupération de la liste de tous les noms de champs de signature en utilisant ‘get_signature_names()’.
Itération à travers chaque signature et vérification de sa validité avec ‘verify_signature()’.
Lever une exception si une signature échoue la vérification.

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

Signer avec un certificat externe

Cet extrait de code montre comment ajouter et signer un champ de signature numérique dans un document PDF en utilisant Aspose.PDF for Python avec un certificat externe :

Ouverture du fichier PDF en tant que flux binaire.
Création d’un SignatureField et placement sur la première page du document à une position spécifiée.
Récupération d’un certificat numérique local à l’aide d’une méthode personnalisée get_local_certificate().
Configuration d’un ExternalSignature avec des métadonnées telles que l’autorité, le motif et les coordonnées.
Attribuer un nom de champ unique au champ de signature (partial_name = “sig1”).
Ajouter le champ de signature aux champs de formulaire du PDF.
Signer le champ avec le certificat externe.
Enregistrer le document signé dans un fichier de sortie.

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)

Sujets de sécurité associés

Python-Net: Chiffrer et déchiffrer des fichiers PDF en Python

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

La gestion de la sécurité des documents est essentielle lorsqu’on travaille avec du contenu sensible ou crucial pour l’entreprise. Aspose.PDF for Python via .NET fournit une API robuste pour appliquer programmatiquement le chiffrement, contrôler l’accès via les autorisations et déchiffrer les fichiers PDF protégés.

Cet article guide les développeurs Python à travers des exemples pratiques pour définir les privilèges, appliquer et supprimer le chiffrement, modifier les mots de passe et détecter les états de protection — le tout dans le cadre d’un flux de travail PDF.

Aspose.PDF for Python via .NET donne aux développeurs un contrôle total sur la sécurité des PDF:

Définir les privilèges - Contrôle d’accès granulaire à l’aide des autorisations. Chiffrer le fichier - Appliquer le chiffrement AES ou RC4 avec des mots de passe personnalisés. Déchiffrer le fichier - Supprimer la sécurité à l’aide du mot de passe propriétaire. Changer les mots de passe - Faire pivoter ou mettre à jour les informations d\u00e9\u00a0identification sans alt\u00e9rer le contenu. Inspecter la sécurité - Détecter l’état du chiffrement ou les types de mot de passe requis.

Utilisez cette page lorsque vous devez protéger des documents PDF avec des mots de passe, restreindre l’impression ou la copie, faire pivoter les informations d’identification, ou vérifier si un document est chiffré.

Définir les privilèges sur un fichier PDF existant

Vous pouvez restreindre ou autoriser des opérations spécifiques (par exemple, l’impression, la copie, le remplissage de formulaires) en attribuant des mots de passe utilisateur et propriétaire ainsi que des privilèges d’accès.

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)

Chiffrer le fichier PDF en utilisant différents types de chiffrement et algorithmes

Le chiffrement d’un PDF garantit que seuls les utilisateurs disposant d’identifiants valides peuvent ouvrir ou modifier le fichier.

Termes clés :

Mot de passe utilisateur. Requis pour ouvrir le document.
Mot de passe propriétaire. Nécessaire pour modifier les autorisations ou supprimer le chiffrement.
KeySize. Utilisez AE_SX128 pour une sécurité maximale dans les flux de travail modernes.

Le fragment de code suivant vous montre comment chiffrer des fichiers 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)

Décrypter le fichier PDF en utilisant le mot de passe propriétaire

Pour supprimer la protection par mot de passe et rétablir l’accès complet :

Charge le PDF chiffré en utilisant le mot de passe correct (‘password’ est le mot de passe utilisateur ou propriétaire).
Supprime toutes les protections par mot de passe et les paramètres de chiffrement du document.
Enregistre le PDF désormais non protégé dans le fichier de sortie spécifié.

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)

Chiffrer et déchiffrer un PDF avec des certificats à clé publique

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

Modifier le mot de passe d’un fichier PDF

Mettre à jour les informations d’identification de sécurité (mot de passe utilisateur et propriétaire) d’un document PDF tout en préservant son contenu et sa structure.

Ouvre le PDF en utilisant le mot de passe propriétaire existant (‘owner’), ce qui donne un accès complet, y compris la permission de modifier les paramètres de sécurité.
Remplace les anciens mots de passe par un nouveau mot de passe utilisateur (’newuser’) et un nouveau mot de passe propriétaire (’newowner’).
Enregistre le PDF avec les paramètres de mot de passe mis à jour.

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)

Comment - déterminer si le PDF source est protégé par mot de passe

Déterminez le mot de passe correct à partir du tableau

Dans certains scénarios, vous pourriez devoir identifier le mot de passe correct parmi une liste de candidats potentiels afin d’accéder à un PDF sécurisé. Le fragment de code ci‑dessous montre comment vérifier si un fichier PDF est protégé par mot de passe, puis tenter de le débloquer en parcourant une liste prédéfinie de mots de passe à l’aide d’Aspose.PDF for Python via .NET.

Le processus comprend :

Utilisation de PdfFileInfo pour détecter si le PDF est chiffré.
Essaye d’ouvrir le PDF avec chaque mot de passe en utilisant ap.Document().
Si l’opération réussit, il affiche le nombre de pages.
Sinon, il intercepte l’exception et signale le mot de passe incorrect.

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