Documentation – Amankan dan Tandatangani File PDF di Python

Python-Net: Tambahkan tanda tangan digital atau tanda tangani PDF secara digital di Python

Fri, 12 Jun 2026 00:00:00 +0000

Tandatangani PDF dengan tanda tangan digital

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)

Sebuah tanda tangan terpisah PKCS#7 menambahkan tanda tangan digital ke dokumen tanpa menyematkan konten ke dalam blok tanda tangan.

Gunakan contoh-contoh ini ketika Anda perlu menerapkan tanda tangan berbasis sertifikat pada file PDF, memverifikasi keabsahan tanda tangan, atau menambahkan cap waktu tepercaya ke dokumen yang ditandatangani.

Contoh berikut menandatangani dokumen PDF menggunakan tanda tangan digital PKCS#7 terpisah, menerapkan tanda tangan pada halaman pertama di area persegi panjang yang ditentukan.

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)

Verifikasi semua tanda tangan digital dalam dokumen PDF

Membuat sebuah instance PdfFileSignature yang memungkinkan Anda berinteraksi dengan tanda tangan dalam PDF.
Dapatkan daftar nama tanda tangan get_signature_names(True).
Memeriksa tanda tangan pertama dalam daftar verify_signature untuk kepatuhan terhadap sertifikat yang ditentukan.

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

Verifikasi tanda tangan dengan file sertifikat kunci publik

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

Verifikasi tanda tangan dengan sertifikat yang diekstrak dari file

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)

Verifikasi tanda tangan dengan validasi rantai sertifikat diaktifkan

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

Tambahkan cap waktu ke tanda tangan digital

Cara menandatangani PDF secara digital dengan cap waktu

Aspose.PDF for Python mendukung penandatanganan digital PDF dengan server timestamp atau layanan Web.

Untuk memenuhi persyaratan ini, PengaturanTimestamp kelas telah ditambahkan ke namespace Aspose.PDF. Silakan lihat cuplikan kode berikut yang memperoleh timestamp dan menambahkannya ke dokumen 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)

Menandatangani dokumen PDF menggunakan ECDSA

Menandatangani dokumen PDF menggunakan ECDSA (Elliptic Curve Digital Signature Algorithm) melibatkan penggunaan kriptografi kurva eliptik untuk menghasilkan tanda tangan digital.

Potongan kode di atas menggambarkan cara menerapkan tanda tangan digital terpisah PKCS#7 pada dokumen PDF menggunakan Aspose.PDF for Python. Dengan memuat dokumen, mengonfigurasi tampilan tanda tangan dan pengaturan keamanan, serta menyimpan hasilnya, contoh ini menunjukkan alur kerja lengkap dan dapat diandalkan untuk menandatangani file PDF secara digital.

Metode ini memastikan keaslian dan integritas dokumen dengan menyematkan tanda tangan yang aman dan dapat diverifikasi pada halaman pertama. Penggunaan SHA-256 sebagai algoritma digest memenuhi standar kriptografi modern, sementara kemampuan untuk mengontrol penempatan tanda tangan memberikan fleksibilitas untuk tanda persetujuan yang terlihat.

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)

Verifikasi tanda tangan ECDSA dalam dokumen 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")

Topik Keamanan Terkait

Python-Net: Ekstrak Informasi Tanda Tangan dari PDF di Python

Fri, 12 Jun 2026 00:00:00 +0000

Ekstrak Gambar dari Field Tanda Tangan

Aspose.PDF for Python via .NET memungkinkan Anda mengambil gambar visual yang disematkan dalam sebuah BidangTandaTangan. Ini berguna ketika Anda perlu menampilkan atau mengarsipkan tampilan tanda tangan tanpa merender PDF lengkap.

Contoh di bawah ini mengiterasi semua bidang formulir, menemukan masing-masing SignatureField, dan menyimpan gambarnya sebagai file 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)

Baca Detail Algoritma Tanda Tangan

Gunakan PdfFileSignature.get_signatures_info() untuk membaca metadata kriptografi untuk setiap tanda tangan dalam dokumen — termasuk algoritma digest, tipe algoritma, standar kriptografi, dan nama tanda tangan:

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)

Ekstrak Sertifikat Digital dari Bidang Tanda Tangan

Gunakan extract_certificate metode pada sebuah SignatureField untuk mengambil sertifikat yang disematkan sebagai aliran byte dan menyimpannya ke disk untuk validasi eksternal:

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

Ekstrak Sertifikat menggunakan Facade PdfFileSignature

PdfFileSignature.try_extract_certificate() menyediakan cara alternatif untuk mengambil sertifikat berdasarkan nama tanda tangan. Contoh berikut mengiterasi semua nama tanda tangan dan mencoba ekstraksi untuk masing-masing:

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

Verifikasi Tanda Tangan Digital Eksternal

Untuk memastikan bahwa dokumen tidak dimodifikasi setelah penandatanganan, verifikasi setiap tanda tangan eksternal menggunakan PdfFileSignature.verify_signature(). Contoh di bawah ini menimbulkan pengecualian untuk setiap tanda tangan yang gagal verifikasi:

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

Deteksi Tanda Tangan yang Terkompromi

SignaturesCompromiseDetector memeriksa apakah tanda tangan digital apa pun dalam dokumen telah dibatalkan oleh perubahan selanjutnya. Gunakan ini dalam alur kerja hukum, keuangan, atau kepatuhan di mana integritas dokumen harus dijamin.

Contoh di bawah ini memeriksa tanda tangan yang terkompromi dan melaporkan nama-namanya bersama dengan cakupan tanda tangan keseluruhan dari dokumen:

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)

Topik Keamanan Terkait

Python-Net: Menandatangani Dokumen PDF dari Kartu Pintar dengan Python

Fri, 12 Jun 2026 00:00:00 +0000

Aspose.PDF menyediakan kemampuan kuat untuk mengintegrasikan komponen tanda tangan visual dan kriptografis, memastikan keaslian serta tampilan profesional dalam dokumen PDF yang ditandatangani secara digital.

Gunakan alur kerja ini ketika proses penandatanganan Anda bergantung pada sertifikat yang disimpan dalam perangkat berbasis perangkat keras seperti kartu pintar, token USB, atau penyimpanan sertifikat yang dikelola.

Menandatangani dengan Kartu Pintar Menggunakan Bidang Tanda Tangan

Contoh ini menunjukkan cara menandatangani dokumen PDF secara digital menggunakan sertifikat eksternal dengan Aspose.PDF for Python dan menerapkan gambar tampilan tanda tangan khusus:

Membuka dokumen PDF.
Membuat objek PdfFileSignature dan mengaitkannya ke dokumen.
Mengambil sertifikat digital lokal menggunakan metode khusus get_local_certificate().
Menyiapkan ExternalSignature berdasarkan sertifikat yang dipilih.
Menerapkan gambar tampilan tanda tangan khusus (mis., logo perusahaan atau tanda tangan tulisan tangan).
Menandatangani secara digital halaman pertama dokumen dengan metadata yang ditentukan (alasan, kontak, lokasi).
Menyimpan dokumen yang ditandatangani ke file output baru.

Metode ini ideal untuk kasus di mana tanda tangan harus diterapkan secara programatis menggunakan sertifikat eksternal—seperti token perangkat keras, penyimpanan sertifikat, atau penyedia tepercaya—dan ditampilkan dengan tata letak visual yang dipersonalisasi.

Berikut adalah cuplikan kode untuk menandatangani dokumen PDF dari kartu pintar:

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)

Verifikasi Tanda Tangan Digital

Potongan kode ini menunjukkan cara memverifikasi tanda tangan digital dalam dokumen PDF menggunakan Aspose.PDF for Python:

Membuka file PDF.
Membuat ‘PdfFileSignature object’ dan mengaitkannya ke dokumen.
Mengambil daftar semua nama bidang tanda tangan menggunakan ‘get_signature_names()’.
Melakukan iterasi melalui setiap tanda tangan dan memverifikasi keabsahannya dengan ‘verify_signature()’.
Menaikkan pengecualian jika ada tanda tangan yang gagal verifikasi.

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

Tanda tangani dengan Sertifikat Eksternal

Potongan kode ini menunjukkan cara menambahkan dan menandatangani bidang tanda tangan digital dalam dokumen PDF menggunakan Aspose.PDF for Python dengan sertifikat eksternal:

Membuka file PDF sebagai aliran biner.
Membuat SignatureField dan menempatkannya pada halaman pertama dokumen pada posisi yang ditentukan.
Mengambil sertifikat digital lokal menggunakan metode khusus get_local_certificate().
Menyiapkan ExternalSignature dengan metadata seperti otoritas, alasan, dan informasi kontak.
Menetapkan nama field unik ke bidang tanda tangan (partial_name = "sig1").
Menambahkan bidang tanda tangan ke bidang formulir PDF.
Menandatangani bidang dengan sertifikat eksternal.
Menyimpan dokumen yang ditandatangani ke file output.

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)

Topik Keamanan Terkait

Python-Net: Enkripsi dan Dekripsi File PDF di Python

Fri, 12 Jun 2026 00:00:00 +0000

Mengelola keamanan dokumen sangat penting saat bekerja dengan konten sensitif atau kritis bisnis. Aspose.PDF for Python via .NET menyediakan API yang kuat untuk secara programatis menerapkan enkripsi, mengontrol akses melalui izin, dan mendekripsi file PDF yang dilindungi.

Artikel ini membimbing pengembang Python melalui contoh praktis untuk mengatur hak istimewa, menerapkan dan menghapus enkripsi, mengubah kata sandi, serta mendeteksi status perlindungan — semua dalam alur kerja PDF.

Aspose.PDF for Python via .NET memberi pengembang kontrol penuh atas keamanan PDF:

Set Privileges - Kontrol akses terperinci menggunakan izin. Enkripsi File - Terapkan enkripsi AES atau RC4 dengan kata sandi khusus. Decrypt File - Hapus keamanan menggunakan kata sandi pemilik. Ubah Kata Sandi - Rotasi atau perbarui kredensial tanpa mengubah konten. Periksa Keamanan - Deteksi status enkripsi atau tipe kata sandi yang diperlukan.

Gunakan halaman ini ketika Anda perlu melindungi dokumen PDF dengan kata sandi, membatasi pencetakan atau penyalinan, memutar kredensial, atau memeriksa apakah sebuah dokumen terenkripsi.

Atur Hak Istimewa pada File PDF yang Ada

Anda dapat membatasi atau mengizinkan operasi tertentu (mis., pencetakan, penyalinan, pengisian formulir) dengan menetapkan kata sandi pengguna dan pemilik serta hak akses.

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)

Enkripsi File PDF menggunakan Berbagai Tipe Enkripsi dan Algoritma

Mengenkripsi sebuah PDF memastikan hanya pengguna dengan kredensial yang valid yang dapat membuka atau memodifikasi file tersebut.

Istilah Kunci:

Password Pengguna. Diperlukan untuk membuka dokumen.
Kata Sandi Pemilik. Diperlukan untuk mengubah izin atau menghapus enkripsi.
KeySize. Gunakan AE_SX128 untuk keamanan maksimum dalam alur kerja modern.

Potongan kode berikut menunjukkan cara mengenkripsi file 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)

Dekripsi File PDF menggunakan Kata Sandi Pemilik

Untuk menghapus perlindungan kata sandi dan memulihkan akses penuh:

Muat PDF terenkripsi menggunakan kata sandi yang benar (‘password’ adalah kata sandi pengguna atau pemilik).
Menghapus semua perlindungan kata sandi dan pengaturan enkripsi dari dokumen.
Menyimpan PDF yang kini tidak dilindungi ke file output yang ditentukan.

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)

Enkripsi dan Dekripsi PDF dengan Sertifikat Kunci Publik

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

Ubah Kata Sandi File PDF

Untuk memperbarui kredensial keamanan (kata sandi pengguna dan pemilik) dari sebuah dokumen PDF sambil mempertahankan konten dan strukturnya.

Membuka PDF menggunakan password pemilik yang sudah ada (‘owner’), yang memberikan akses penuh termasuk izin untuk mengubah pengaturan keamanan.
Mengganti password lama dengan password pengguna baru (’newuser’) dan password pemilik baru (’newowner’).
Menyimpan PDF dengan pengaturan kata sandi yang diperbarui.

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)

Cara - menentukan apakah PDF sumber dilindungi kata sandi

Tentukan kata sandi yang benar dari Array

Dalam beberapa skenario, Anda mungkin perlu mengidentifikasi kata sandi yang benar dari daftar kandidat potensial untuk mengakses PDF yang diamankan. Potongan kode di bawah ini menunjukkan cara memeriksa apakah file PDF dilindungi kata sandi dan kemudian mencoba membuka kuncinya dengan mengiterasi daftar kata sandi yang telah ditentukan menggunakan Aspose.PDF for Python via .NET.

Proses meliputi:

Menggunakan PdfFileInfo untuk mendeteksi apakah PDF terenkripsi.
Mencoba membuka PDF dengan setiap kata sandi menggunakan ap.Document().
Jika berhasil, itu mencetak jumlah halaman.
Jika tidak, itu menangkap pengecualian dan melaporkan kata sandi yang gagal.

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