Jak dodać cyfrowe podpisy PDF w ASP.NET Core

Czym jest podpis cyfrowy w formacie PDF i dlaczego ma znaczenie?

Podpis cyfrowy to mechanizm kryptograficzny, który wiąże tożsamość podpisującego z konkretną wersją dokumentu. Różni się on od zwykłego podpisu elektronicznego — takiego jak wpisane imię i nazwisko lub zeskanowany obraz — ponieważ wykorzystuje kryptografię klucza publicznego do tworzenia weryfikowalnej pieczęci zabezpieczonej przed manipulacją.

Kiedy ktoś podpisuje cyfrowo plik PDF, oprogramowanie do podpisywania generuje skrót zawartości dokumentu i szyfruje ten skrót za pomocą klucza prywatnego podpisującego. Powstały podpis jest osadzany w pliku PDF wraz z certyfikatem publicznym podpisującego. Każdy czytnik plików PDF obsługujący podpisy cyfrowe — w tym Adobe Acrobat Reader i przeglądarki plików PDF wbudowane w nowoczesne przeglądarki — może odszyfrować skrót za pomocą klucza publicznego i porównać go ze świeżo obliczonym skrótem dokumentu. Jeśli skróty się zgadzają, dokument jest autentyczny i niezmieniony.

Jak zainstalować IronPDF w projekcie ASP.NET Core?

Najszybszym sposobem na uruchomienie środowiska podpisywania jest pakiet NuGet. Otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Alternatywnie, kliknij prawym przyciskiem myszy projekt w Solution Explorer, wybierz "Zarządzaj pakietami NuGet", wyszukaj IronPdf i kliknij Zainstaluj. Po instalacji dodaj następujące dyrektywy using na początku klasy kontrolera lub usługi:

using IronPdf;
using IronPdf.Signing;

using IronPdf;
using IronPdf.Signing;

Imports IronPdf
Imports IronPdf.Signing

IronPDF jest przeznaczony dla platform .NET 8 oraz .NET 9/10, dzięki czemu naturalnie wpisuje się w nowoczesne projekty ASP.NET Core. Szczegółowy opis pierwszej konfiguracji znajduje się w przewodniku szybkiego startu IronPDF.

Jak podpisać plik PDF za pomocą pliku certyfikatu w ASP.NET Core?

Najpopularniejszym podejściem do podpisywania jest użycie pliku certyfikatu .pfx lub .p12. Pliki te łączą klucz prywatny i łańcuch certyfikatów publicznych w jedno archiwum chronione hasłem. Można je uzyskać od zaufanego urzędu certyfikacji (CA), takiego jak DigiCert lub GlobalSign, lub wygenerować certyfikat z podpisem własnym do celów programistycznych i testowych.

Poniższy przykład generuje plik PDF z kodu HTML i stosuje podpis cyfrowy oparty na certyfikacie:

using IronPdf;
using IronPdf.Signing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-certificate", (IWebHostEnvironment env) =>
{
    // Generate a PDF from HTML content
    var renderer = new ChromePdfRenderer();
    var document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>");

    // Locate the PFX certificate on the server
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");

    // Build the signature object
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningContact = "legal@yourcompany.com",
        SigningLocation = "Chicago, IL, USA",
        SigningReason = "Document Approval"
    };

    // Apply the signature and save
    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-contract.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-contract.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Signing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-certificate", (IWebHostEnvironment env) =>
{
    // Generate a PDF from HTML content
    var renderer = new ChromePdfRenderer();
    var document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>");

    // Locate the PFX certificate on the server
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");

    // Build the signature object
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningContact = "legal@yourcompany.com",
        SigningLocation = "Chicago, IL, USA",
        SigningReason = "Document Approval"
    };

    // Apply the signature and save
    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-contract.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-contract.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/sign-with-certificate", Function(env As IWebHostEnvironment)
    ' Generate a PDF from HTML content
    Dim renderer = New ChromePdfRenderer()
    Dim document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>")

    ' Locate the PFX certificate on the server
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")

    ' Build the signature object
    Dim signature = New PdfSignature(certPath, "yourPassword") With {
        .SigningContact = "legal@yourcompany.com",
        .SigningLocation = "Chicago, IL, USA",
        .SigningReason = "Document Approval"
    }

    ' Apply the signature and save
    document.Sign(signature)
    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "signed-contract.pdf")
    document.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "signed-contract.pdf")
End Function)

app.Run()

ChromePdfRenderer konwertuje dowolny prawidłowy ciąg znaków HTML lub adres URL na plik PDF. Konstruktor PdfSignature przyjmuje ścieżkę certyfikatu i hasło, a opcjonalne właściwości (SigningContact, SigningLocation, SigningReason) dodają metadane, które przeglądarki PDF wyświetlają w panelu podpisu. Metoda Sign osadza podpis kryptograficzny, a SaveAs zapisuje podpisany plik na dysku.

var stream = new MemoryStream();
document.SaveAs(stream);
stream.Position = 0;
return Results.File(stream, "application/pdf", "signed-contract.pdf");

var stream = new MemoryStream();
document.SaveAs(stream);
stream.Position = 0;
return Results.File(stream, "application/pdf", "signed-contract.pdf");

Dim stream As New MemoryStream()
document.SaveAs(stream)
stream.Position = 0
Return Results.File(stream, "application/pdf", "signed-contract.pdf")

Jak dodać widoczny obraz podpisu do pliku PDF?

Podpisy kryptograficzne chronią integralność dokumentu, ale są niewidoczne w wygenerowanym pliku PDF. Wiele procesów — zwłaszcza tych związanych z umowami lub pismami — wymaga również widocznej reprezentacji, takiej jak zeskanowany podpis odręczny lub pieczęć firmowa, wydrukowana na stronie.

IronPDF obsługuje to za pomocą metody LoadSignatureImageFromFile. Metoda przyjmuje ścieżkę do obrazu, indeks strony oraz IronSoftware.Drawing.Rectangle, który określa położenie i wymiary widocznego podpisu:

using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-visible-image", (IWebHostEnvironment env) =>
{
    // Load an existing PDF (for example, an invoice template)
    string pdfPath = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf");
    var document = PdfDocument.FromFile(pdfPath);

    // Paths to the certificate and the signature image
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    string imagePath = Path.Combine(env.ContentRootPath, "Images", "signature.png");

    // Define where the visible signature appears (x, y, width, height in points)
    var signatureArea = new Rectangle(50, 680, 200, 80);

    var signature = new PdfSignature(certPath, "yourPassword");
    signature.LoadSignatureImageFromFile(imagePath, pageIndex: 0, signatureArea);

    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-invoice.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-visible-image", (IWebHostEnvironment env) =>
{
    // Load an existing PDF (for example, an invoice template)
    string pdfPath = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf");
    var document = PdfDocument.FromFile(pdfPath);

    // Paths to the certificate and the signature image
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    string imagePath = Path.Combine(env.ContentRootPath, "Images", "signature.png");

    // Define where the visible signature appears (x, y, width, height in points)
    var signatureArea = new Rectangle(50, 680, 200, 80);

    var signature = new PdfSignature(certPath, "yourPassword");
    signature.LoadSignatureImageFromFile(imagePath, pageIndex: 0, signatureArea);

    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-invoice.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing
Imports IronSoftware.Drawing
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/sign-with-visible-image", Function(env As IWebHostEnvironment)
    ' Load an existing PDF (for example, an invoice template)
    Dim pdfPath As String = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf")
    Dim document = PdfDocument.FromFile(pdfPath)

    ' Paths to the certificate and the signature image
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")
    Dim imagePath As String = Path.Combine(env.ContentRootPath, "Images", "signature.png")

    ' Define where the visible signature appears (x, y, width, height in points)
    Dim signatureArea As New Rectangle(50, 680, 200, 80)

    Dim signature As New PdfSignature(certPath, "yourPassword")
    signature.LoadSignatureImageFromFile(imagePath, pageIndex:=0, signatureArea)

    document.Sign(signature)
    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf")
    document.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "signed-invoice.pdf")
End Function)

app.Run()

Widoczny obraz podpisu jest umieszczany na wskazanej stronie w podanych przez Ciebie współrzędnych. Podpis kryptograficzny jest nakładany na cały dokument jednocześnie, dzięki czemu w ramach jednej operacji uzyskujesz zarówno zabezpieczenie, jak i wizualne potwierdzenie.

Jeśli obraz znajduje się w pamięci (na przykład pobrany z bazy danych lub pamięci w chmurze), należy użyć zamiast tego LoadSignatureImageFromStream. Aby uzyskać więcej informacji na temat opcji podpisywania wizualnego, zapoznaj się z przewodnikiem dotyczącym podpisywania plików PDF.

Jak utworzyć pola formularza podpisu dla zewnętrznych sygnatariuszy?

W niektórych procesach dokument jest tworzony przez system, ale musi zostać podpisany przez stronę zewnętrzną — klienta, partnera lub organ regulacyjny. Zamiast zbierać certyfikat od tej strony z góry, osadzasz w PDF specjalne pole formularza na podpis i wysyłasz do niej dokument. Odbiorcy otwierają plik PDF w programie Adobe Acrobat Reader lub innej kompatybilnej przeglądarce, klikają pole podpisu i stosują własny certyfikat lub podpis elektroniczny.

using IronPdf;
using IronPdf.Forms;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/generate-signable-form", (IWebHostEnvironment env) =>
{
    // Render the document that requires a client signature
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(@"
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ");

    // Define the signature field: name, page, x, y, width, height (in points)
    var signatureField = new SignatureFormField(
        "ClientSignature",
        pageIndex: 0,
        x: 50,
        y: 600,
        width: 300,
        height: 100
    );

    pdf.Form.Add(signatureField);

    string outputPath = Path.Combine(Path.GetTempPath(), "client-agreement.pdf");
    pdf.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "client-agreement.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Forms;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/generate-signable-form", (IWebHostEnvironment env) =>
{
    // Render the document that requires a client signature
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(@"
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ");

    // Define the signature field: name, page, x, y, width, height (in points)
    var signatureField = new SignatureFormField(
        "ClientSignature",
        pageIndex: 0,
        x: 50,
        y: 600,
        width: 300,
        height: 100
    );

    pdf.Form.Add(signatureField);

    string outputPath = Path.Combine(Path.GetTempPath(), "client-agreement.pdf");
    pdf.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "client-agreement.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Forms
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/generate-signable-form", Function(env As IWebHostEnvironment)
    ' Render the document that requires a client signature
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf("
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ")

    ' Define the signature field: name, page, x, y, width, height (in points)
    Dim signatureField = New SignatureFormField(
        "ClientSignature",
        pageIndex:=0,
        x:=50,
        y:=600,
        width:=300,
        height:=100
    )

    pdf.Form.Add(signatureField)

    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "client-agreement.pdf")
    pdf.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "client-agreement.pdf")
End Function)

app.Run()

Parametry konstruktora SignatureFormField odpowiadają bezpośrednio pozycji pola na stronie. Kiedy odbiorca otworzy plik PDF, zobaczy wyraźnie zaznaczone pole, w którym powinien umieścić swój podpis. Wypełniony formularz można następnie zwrócić do systemu, gdzie można go załadować, zweryfikować osadzony podpis i zarchiwizować.

Więcej informacji na temat obsługi formularzy PDF — w tym odczytywania przesłanych danych z formularzy — można znaleźć w przewodniku po edycji formularzy PDF.

Jak programowo zweryfikować podpis cyfrowy?

Po podpisaniu i zwrocie dokumentu może zaistnieć potrzeba sprawdzenia, czy podpis jest nadal ważny i czy dokument nie został zmieniony. IronPDF udostępnia weryfikację podpisu poprzez obiekt PdfDocument:

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/verify-signature", (IWebHostEnvironment env) =>
{
    string signedPath = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf");
    var document = PdfDocument.FromFile(signedPath);

    // Retrieve all embedded signatures
    var signatures = document.GetSignatures();

    foreach (var sig in signatures)
    {
        bool isValid = sig.VerifySignature();
        string status = isValid
            ? $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}"
            : "INVALID -- document may have been tampered with";

        Console.WriteLine(status);
    }

    return Results.Ok(new { SignatureCount = signatures.Count });
});

app.Run();

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/verify-signature", (IWebHostEnvironment env) =>
{
    string signedPath = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf");
    var document = PdfDocument.FromFile(signedPath);

    // Retrieve all embedded signatures
    var signatures = document.GetSignatures();

    foreach (var sig in signatures)
    {
        bool isValid = sig.VerifySignature();
        string status = isValid
            ? $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}"
            : "INVALID -- document may have been tampered with";

        Console.WriteLine(status);
    }

    return Results.Ok(new { SignatureCount = signatures.Count });
});

app.Run();

Imports IronPdf
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/verify-signature", Function(env As IWebHostEnvironment)
                                    Dim signedPath As String = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf")
                                    Dim document = PdfDocument.FromFile(signedPath)

                                    ' Retrieve all embedded signatures
                                    Dim signatures = document.GetSignatures()

                                    For Each sig In signatures
                                        Dim isValid As Boolean = sig.VerifySignature()
                                        Dim status As String = If(isValid,
                                            $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}",
                                            "INVALID -- document may have been tampered with")

                                        Console.WriteLine(status)
                                    Next

                                    Return Results.Ok(New With {.SignatureCount = signatures.Count})
                                End Function)

app.Run()

GetSignatures() zwraca listę wszystkich podpisów cyfrowych osadzonych w pliku PDF. Każdy obiekt PdfDigitalSignature udostępnia VerifySignature(), nazwę podpisującego, znacznik czasu podpisania oraz łańcuch certyfikatów. Te informacje wystarczą do stworzenia ścieżki audytu lub pulpitu nawigacyjnego do zarządzania dokumentami, który sygnalizuje wszelkie pliki PDF z uszkodzonymi lub wygasłymi podpisami.

Jak radzisz sobie z zarządzaniem certyfikatami w środowisku produkcyjnym?

Przechowywanie pliku .pfx w systemie plików działa podczas tworzenia oprogramowania, ale nie nadaje się do środowiska produkcyjnego. Pliki certyfikatów zawierają klucze prywatne, a jeśli plik zostanie naruszony, zagrożone są wszystkie dokumenty podpisane tym kluczem.

string certBase64 = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.");

byte[] certBytes = Convert.FromBase64String(certBase64);
string certPassword = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.");

var signature = new PdfSignature(certBytes, certPassword);

string certBase64 = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.");

byte[] certBytes = Convert.FromBase64String(certBase64);
string certPassword = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.");

var signature = new PdfSignature(certBytes, certPassword);

Imports System

Dim certBase64 As String = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
If certBase64 Is Nothing Then
    Throw New InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.")
End If

Dim certBytes As Byte() = Convert.FromBase64String(certBase64)
Dim certPassword As String = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
If certPassword Is Nothing Then
    Throw New InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.")
End If

Dim signature = New PdfSignature(certBytes, certPassword)

Jak efektywnie podpisywać zbiorczo wiele plików PDF?

Gdy trzeba podpisać dziesiątki lub setki dokumentów w ramach jednej operacji — na przykład podpisać całą partię faktur na koniec miesiąca — jednokrotne załadowanie certyfikatu i ponowne wykorzystanie obiektu PdfSignature we wszystkich dokumentach zmniejsza obciążenie:

using IronPdf;
using IronPdf.Signing;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/batch-sign", (IWebHostEnvironment env) =>
{
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningReason = "Batch Invoice Approval"
    };

    string[] invoicePaths = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    );

    string outputDir = Path.Combine(env.ContentRootPath, "Signed");
    Directory.CreateDirectory(outputDir);

    foreach (string invoicePath in invoicePaths)
    {
        var doc = PdfDocument.FromFile(invoicePath);
        doc.Sign(signature);
        string outputFile = Path.Combine(outputDir, Path.GetFileName(invoicePath));
        doc.SaveAs(outputFile);
    }

    return Results.Ok(new { SignedCount = invoicePaths.Length });
});

app.Run();

using IronPdf;
using IronPdf.Signing;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/batch-sign", (IWebHostEnvironment env) =>
{
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningReason = "Batch Invoice Approval"
    };

    string[] invoicePaths = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    );

    string outputDir = Path.Combine(env.ContentRootPath, "Signed");
    Directory.CreateDirectory(outputDir);

    foreach (string invoicePath in invoicePaths)
    {
        var doc = PdfDocument.FromFile(invoicePath);
        doc.Sign(signature);
        string outputFile = Path.Combine(outputDir, Path.GetFileName(invoicePath));
        doc.SaveAs(outputFile);
    }

    return Results.Ok(new { SignedCount = invoicePaths.Length });
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/batch-sign", Function(env As IWebHostEnvironment)
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")
    Dim signature As New PdfSignature(certPath, "yourPassword") With {
        .SigningReason = "Batch Invoice Approval"
    }

    Dim invoicePaths As String() = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    )

    Dim outputDir As String = Path.Combine(env.ContentRootPath, "Signed")
    Directory.CreateDirectory(outputDir)

    For Each invoicePath As String In invoicePaths
        Dim doc = PdfDocument.FromFile(invoicePath)
        doc.Sign(signature)
        Dim outputFile As String = Path.Combine(outputDir, Path.GetFileName(invoicePath))
        doc.SaveAs(outputFile)
    Next

    Return Results.Ok(New With {.SignedCount = invoicePaths.Length})
End Function)

app.Run()

Utworzenie obiektu PdfSignature poza pętlą oznacza, że plik certyfikatu jest odczytywany i analizowany tylko raz. Każda iteracja ładuje, podpisuje i zapisuje osobny plik PDF. W przypadku bardzo dużych partii warto rozważyć przetwarzanie dokumentów równolegle przy użyciu Parallel.ForEach — operacje podpisywania w IronPDF są bezpieczne dla wątków, gdy każda instancja PdfDocument jest izolowana do jednego wątku.

Jak rozwiązywać typowe błędy związane z podpisywaniem?

Jakie są Twoje kolejne kroki?

Cyfrowe podpisywanie plików PDF w ASP.NET Core staje się proste, gdy zrozumiesz trzy podstawowe operacje: ładowanie certyfikatu, wywołanie Sign oraz zapisanie wyniku. IronPDF zajmuje się skomplikowanymi operacjami kryptograficznymi, dzięki czemu możesz skupić się na logice biznesowej swojej aplikacji.

Aby kontynuować tworzenie przepływu pracy z dokumentami, zapoznaj się z poniższymi powiązanymi tematami:

• Jak generować pliki PDF z HTML w ASP.NET Core — podstawa większości procesów podpisywania dokumentów
• Jak dodawać hasła i uprawnienia do plików PDF — połącz podpisywanie z szyfrowaniem, aby zapewnić maksymalne bezpieczeństwo
• Jak łączyć i dzielić pliki PDF — tworzenie pakietów zawierających wiele dokumentów przed podpisaniem
• Opcje licencyjne IronPDF — wybierz plan, który pasuje do Twojego wdrożenia
• Pakiet IronPDF NuGet — sprawdź najnowszą wersję i dziennik zmian

Zacznij od bezpłatnej wersji próbnej IronPDF i uruchom swój pierwszy podpisany plik PDF w mniej niż godzinę. Jeśli masz pytania lub napotkasz nietypowe sytuacje, zespół wsparcia Iron Software służy pomocą w wdrożeniu niezawodnego i zgodnego z przepisami prawa procesu podpisywania dokumentów.