ASP.NET CoreでPDF電子署名を追加する方法

Install-Package IronPdf
dotnet add package IronPdf

using IronPdf;
using IronPdf.Signing;

Imports IronPdf
Imports IronPdf.Signing

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

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

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

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

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