Hinzufügen von digitalen PDF-Signaturen in ASP.NET Core

Was ist eine digitale PDF-Signatur und warum ist sie wichtig?

Eine digitale Signatur ist ein kryptografischer Mechanismus, der die Identität des Unterzeichners mit einer bestimmten Version eines Dokuments verknüpft. Sie unterscheidet sich von einer einfachen elektronischen Signatur – wie etwa einem getippten Namen oder einem eingescannten Bild – dadurch, dass sie Public-Key-Kryptographie verwendet, um ein überprüfbares, fälschungssicheres Siegel zu erstellen.

Wenn jemand ein PDF digital signiert, erzeugt die Signatursoftware einen Hashwert des Dokumentinhalts und verschlüsselt diesen Hashwert mit dem privaten Schlüssel des Unterzeichners. Die resultierende Signatur wird zusammen mit dem öffentlichen Zertifikat des Unterzeichners in die PDF-Datei eingebettet. Jeder PDF-Reader, der digitale Signaturen unterstützt – einschließlich Adobe Acrobat Reader und in moderne Browser integrierte PDF-Viewer – kann den Hash mit dem öffentlichen Schlüssel entschlüsseln und ihn mit einem neu berechneten Hash des Dokuments vergleichen. Stimmen die Hashwerte überein, ist das Dokument authentisch und unverändert.

Wie installiert man IronPDF in einem ASP.NET Core -Projekt?

Der schnellste Weg zu einer funktionierenden Signaturumgebung führt über das NuGet Paket. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Alternativ können Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt klicken, " NuGet Pakete verwalten" auswählen, nach IronPdf suchen und auf "Installieren" klicken. Fügen Sie nach der Installation die folgenden using Direktiven am Anfang Ihrer Controller- oder Serviceklasse hinzu:

using IronPdf;
using IronPdf.Signing;

using IronPdf;
using IronPdf.Signing;

Imports IronPdf
Imports IronPdf.Signing

IronPDF zielt auf .NET 8 und .NET 9/10 ab und fügt sich daher nahtlos in moderne ASP.NET Core Projekte ein. Eine detaillierte Anleitung zur erstmaligen Einrichtung finden Sie im IronPDF Schnellstartleitfaden .

Wie signiert man eine PDF-Datei mit einer Zertifikatsdatei in ASP.NET Core?

Die gängigste Methode zum Signieren von Zertifikaten verwendet eine Zertifikatsdatei im Format .pfx oder .p12. Diese Dateien bündeln den privaten Schlüssel und die öffentliche Zertifikatskette in einem einzigen passwortgeschützten Archiv. Sie können ein solches Zertifikat von einer vertrauenswürdigen Zertifizierungsstelle (CA) wie DigiCert oder GlobalSign beziehen oder für Entwicklungs- und Testzwecke ein selbstsigniertes Zertifikat erstellen.

Das folgende Beispiel generiert aus HTML eine PDF-Datei und wendet eine zertifikatsbasierte digitale Signatur an:

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 wandelt jede gültige HTML-Zeichenkette oder URL in ein PDF um. Der Konstruktor PdfSignature akzeptiert den Zertifikatspfad und das Passwort, und die optionalen Eigenschaften (SigningContact, SigningLocation, SigningReason) fügen Metadaten hinzu, die PDF-Viewer im Signaturfeld anzeigen. Die Methode Sign bettet die kryptografische Signatur ein, und SaveAs schreibt die signierte Datei auf die Festplatte.

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

Wie fügt man ein sichtbares Signaturbild in eine PDF-Datei ein?

Kryptografische Signaturen schützen die Integrität von Dokumenten, sind aber im gerenderten PDF unsichtbar. Viele Arbeitsabläufe – insbesondere solche, die Verträge oder Briefe betreffen – erfordern auch eine sichtbare Darstellung, wie zum Beispiel eine eingescannte handschriftliche Unterschrift oder einen Firmenstempel, der auf das Papier gedruckt wird.

IronPDF unterstützt dies durch die Methode LoadSignatureImageFromFile. Die Methode akzeptiert einen Bildpfad, einen Seitenindex und ein IronSoftware.Drawing.Rectangle, das die Position und die Abmessungen der sichtbaren Signatur definiert:

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

Das sichtbare Signaturbild wird an den von Ihnen angegebenen Koordinaten auf der ausgewählten Seite eingefügt. Die kryptografische Signatur wird gleichzeitig auf das gesamte Dokument angewendet, sodass Sie in einem einzigen Vorgang sowohl Sicherheit als auch visuelle Bestätigung erhalten.

Wenn sich das Bild im Arbeitsspeicher befindet (z. B. aus einer Datenbank oder einem Cloud-Speicher abgerufen wurde), verwenden Sie stattdessen LoadSignatureImageFromStream. Für einen detaillierteren Einblick in die Möglichkeiten der visuellen Signatur konsultieren Sie bitte die PDF-Anleitung zur Signaturerstellung .

Wie erstellt man Signaturformularfelder für externe Unterzeichner?

In manchen Arbeitsabläufen wird das Dokument von Ihrem System erstellt, muss aber von einer externen Partei – einem Kunden, einem Partner oder einer Aufsichtsbehörde – unterzeichnet werden. Anstatt von der betreffenden Partei im Voraus eine Bescheinigung einzuholen, betten Sie ein spezielles Signaturformularfeld in das PDF ein und senden das Dokument an sie. Die Empfänger öffnen die PDF-Datei in Adobe Acrobat Reader oder einem anderen kompatiblen Anzeigeprogramm, klicken auf das Signaturfeld und fügen ihr eigenes Zertifikat oder ihre elektronische Signatur hinzu.

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

Die Konstruktorparameter SignatureFormField werden direkt der Position des Feldes auf der Seite zugeordnet. Beim Öffnen der PDF-Datei sieht der Empfänger ein deutlich abgegrenztes Feld, in dem seine Unterschrift erfolgen soll. Das ausgefüllte Formular kann dann an Ihr System zurückgesendet werden, wo Sie es laden, die eingebettete Signatur überprüfen und es archivieren können.

Weitere Informationen zur Bearbeitung von PDF-Formularen – einschließlich des Auslesens übermittelter Formulardaten – finden Sie im Leitfaden zur Bearbeitung von PDF-Formularen .

Wie lässt sich eine digitale Signatur programmatisch verifizieren?

Nachdem ein Dokument unterschrieben und zurückgesandt wurde, müssen Sie möglicherweise überprüfen, ob die Unterschrift noch gültig ist und ob das Dokument nicht verändert wurde. IronPDF stellt die Signaturprüfung über das PdfDocument-Objekt bereit:

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() gibt eine Liste aller im PDF eingebetteten digitalen Signaturen zurück. Jedes PdfDigitalSignature-Objekt legt VerifySignature(), den Namen des Unterzeichners, den Zeitstempel der Signatur und die Zertifikatskette offen. Diese Informationen genügen, um einen Prüfpfad oder ein Dokumentenmanagement-Dashboard zu erstellen, das alle PDFs mit fehlerhaften oder abgelaufenen Signaturen kennzeichnet.

Wie handhaben Sie das Zertifikatsmanagement in der Produktion?

Das Speichern einer .pfx Datei im Dateisystem funktioniert während der Entwicklung, ist aber für den Produktiveinsatz nicht geeignet. Zertifikatsdateien enthalten private Schlüssel, und wenn die Datei kompromittiert wird, ist jedes mit diesem Schlüssel signierte Dokument gefährdet.

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)

Wie signiert man mehrere PDFs effizient im Stapelverfahren?

Wenn Sie Dutzende oder Hunderte von Dokumenten in einem Arbeitsgang signieren müssen – beispielsweise einen ganzen Stapel Rechnungen zum Monatsende – reduziert das einmalige Laden des Zertifikats und die Wiederverwendung des Objekts PdfSignature für alle Dokumente den Aufwand:

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

Das Erstellen des PdfSignature-Objekts außerhalb der Schleife bedeutet, dass die Zertifikatsdatei nur einmal gelesen und analysiert wird. Bei jedem Durchlauf wird eine einzelne PDF-Datei geladen, signiert und gespeichert. Bei sehr großen Dokumentenstapeln empfiehlt sich die parallele Verarbeitung von Dokumenten mithilfe von Parallel.ForEach -- Die Signaturvorgänge von IronPDF sind threadsicher, wenn jede PdfDocument Instanz in einem einzigen Thread isoliert ist.

Wie behebt man häufige Signaturfehler?

Was sind Ihre nächsten Schritte?

Das digitale Signieren von PDFs in ASP.NET Core wird unkompliziert, sobald man die drei Kernoperationen verstanden hat: das Laden eines Zertifikats, den Aufruf von Sign und das Speichern des Ergebnisses. IronPDF übernimmt die komplexen kryptografischen Berechnungen, sodass Sie sich auf die Geschäftslogik Ihrer Anwendung konzentrieren können.

Um Ihren Dokumenten-Workflow weiter auszubauen, sollten Sie sich mit diesen verwandten Themen auseinandersetzen:

• Wie man in ASP.NET Core PDFs aus HTML generiert – die Grundlage für die meisten Signatur-Workflows
• So fügen Sie PDF-Passwörter und Berechtigungen hinzu – kombinieren Sie Signierung mit Verschlüsselung für maximale Sicherheit
• So führen Sie PDFs zusammen und teilen sie auf – Erstellen von Dokumentenpaketen vor dem Signieren
• IronPDF -Lizenzierungsoptionen – wählen Sie den Plan, der zu Ihrer Bereitstellung passt
• IronPDF NuGet Paket – prüfen Sie die neueste Version und das Änderungsprotokoll.

Starten Sie mit einer kostenlosen IronPDF Testversion und Ihr erstes signiertes PDF ist in weniger als einer Stunde fertig. Sollten Sie Fragen haben oder auf Sonderfälle stoßen, steht Ihnen das Support-Team von Iron Software zur Verfügung, um Sie bei der Bereitstellung eines zuverlässigen und rechtskonformen Workflows zur Dokumentensignatur zu unterstützen.