Cómo añadir firmas digitales PDF en ASP.NET Core

¿Qué es una firma digital PDF y por qué es importante?

Una firma digital es un mecanismo criptográfico que vincula la identidad del firmante a una versión específica de un documento. Se diferencia de una firma electrónica simple (como un nombre escrito o una imagen escaneada) porque utiliza criptografía de clave pública para crear un sello verificable y a prueba de manipulaciones.

Cuando alguien firma digitalmente un PDF, el software de firma genera un hash del contenido del documento y cifra ese hash con la clave privada del firmante. La firma resultante se incrusta en el PDF junto con el certificado público del firmante. Cualquier lector de PDF que admita firmas digitales (incluido Adobe Acrobat Reader y los visores de PDF integrados en los navegadores modernos) puede descifrar el hash con la clave pública y compararlo con un hash recién calculado del documento. Si los hashes coinciden, el documento es auténtico y no está modificado.

¿Cómo instalar IronPDF en un proyecto ASP.NET Core ?

La ruta más rápida hacia un entorno de firma funcional es el paquete NuGet . Abra la consola del gestor de paquetes en Visual Studio y ejecute:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Alternativamente, haz clic derecho en el proyecto en el Explorador de Soluciones, elige "Administrar paquetes NuGet", busca IronPdf, y haz clic en Instalar. Después de la instalación, añade las siguientes directivas using en la parte superior de tu controlador o clase de servicio:

using IronPdf;
using IronPdf.Signing;

using IronPdf;
using IronPdf.Signing;

Imports IronPdf
Imports IronPdf.Signing

IronPDF está orientado a .NET 8 y .NET 9/10, por lo que se adapta naturalmente a los proyectos ASP.NET Core modernos. Para obtener una guía detallada sobre la configuración inicial, consulte la guía de inicio rápido de IronPDF .

¿Cómo firmar un PDF con un archivo de certificado en ASP.NET Core?

El enfoque de firma más común utiliza un archivo de certificado .pfx o .p12. Estos archivos agrupan la clave privada y la cadena de certificados públicos en un único archivo protegido por contraseña. Puedes obtener uno de una autoridad certificadora (CA) de confianza como DigiCert o GlobalSign, o generar un certificado autofirmado para desarrollo y prueba.

El siguiente ejemplo genera un PDF a partir de HTML y aplica una firma digital basada en certificado:

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 convierte cualquier cadena HTML válida o URL en un PDF. El constructor PdfSignature acepta la ruta del certificado y la contraseña, y las propiedades opcionales (SigningContact, SigningLocation, SigningReason) añaden metadatos que los visores PDF muestran en el panel de firmas. El método Sign incrusta la firma criptográfica, y SaveAs escribe el archivo firmado en el disco.

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

¿Cómo agregar una imagen de firma visible a un PDF?

Las firmas criptográficas protegen la integridad del documento, pero son invisibles en el PDF renderizado. Muchos flujos de trabajo, en particular aquellos que involucran contratos o cartas, también requieren una representación visible, como una firma manuscrita escaneada o un sello de la empresa, impreso en la página.

IronPDF admite esto a través del método LoadSignatureImageFromFile. El método acepta una ruta de imagen, un índice de página, y un IronSoftware.Drawing.Rectangle que define la posición y dimensiones de la firma visible:

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

La imagen visible de la firma se compone en la página especificada, en las coordenadas que proporcione. La firma criptográfica se aplica simultáneamente a todo el documento, lo que le permite obtener seguridad y confirmación visual en una sola operación.

Si la imagen reside en la memoria (obtenida de una base de datos o almacenamiento en la nube, por ejemplo), usa LoadSignatureImageFromStream en su lugar. Para obtener una visión más profunda de las opciones de firma visual, consulte la guía práctica de firma en PDF .

¿Cómo crear campos de formulario de firma para firmantes externos?

En algunos flujos de trabajo, el documento lo crea su sistema, pero debe estar firmado por una parte externa: un cliente, un socio o un organismo regulador. En lugar de recoger un certificado de esa parte por adelantado, usted integra un campo de formulario de firma dedicado en el PDF y les envía el documento. Los destinatarios abren el PDF en Adobe Acrobat Reader u otro visor compatible, hacen clic en el campo de firma y aplican su propio certificado o firma electrónica.

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

Los parámetros del constructor SignatureFormField se asignan directamente a la posición del campo en la página. Cuando el destinatario abre el PDF, ve un cuadro claramente delimitado donde debe ir su firma. Luego, el formulario completo puede devolverse a su sistema, donde podrá cargarlo, validar la firma incorporada y archivarlo.

Para obtener más información sobre el manejo de formularios PDF, incluida la lectura de los datos del formulario enviado, consulte la guía de edición de formularios PDF .

¿Cómo se verifica una firma digital mediante programación?

Después de firmar y devolver un documento, es posible que deba verificar que la firma aún sea válida y que el documento no haya sido alterado. IronPDF expone la verificación de firma a través del objeto 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() devuelve una lista de todas las firmas digitales incrustadas en el PDF. Cada objeto PdfDigitalSignature expone VerifySignature(), el nombre del firmante, la marca de tiempo de la firma, y la cadena de certificados. Esta información es suficiente para crear un registro de auditoría o un panel de gestión de documentos que marque cualquier PDF con firmas rotas o vencidas.

¿Cómo se gestiona la gestión de certificados en producción?

Almacenar un archivo .pfx en el sistema de archivos funciona durante el desarrollo, pero no es adecuado para producción. Los archivos de certificado contienen claves privadas y, si el archivo se ve comprometido, todos los documentos firmados con esa clave están en riesgo.

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)

¿Cómo firmar varios archivos PDF por lotes de manera eficiente?

Cuando necesitas firmar docenas o cientos de documentos en una operación -- por ejemplo, firmar un lote completo de facturas al final del mes -- cargar el certificado una vez y reutilizar el objeto PdfSignature en todos los documentos reduce la sobrecarga:

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

Crear el objeto PdfSignature una vez fuera del bucle significa que el archivo de certificado se lee y analiza solo una vez. Cada iteración carga, firma y guarda un PDF individual. Para lotes muy grandes, considera procesar documentos en paralelo usando Parallel.ForEach -- Las operaciones de firma de IronPDF son seguras para hilos cuando cada instancia de PdfDocument está aislada a un solo hilo.

¿Cómo solucionar errores de firma comunes?

¿Cuales son tus próximos pasos?

La firma digital de PDF en ASP.NET Core se vuelve sencilla una vez que entiendes las tres operaciones principales: cargar un certificado, llamar a Sign, y guardar el resultado. IronPDF se encarga del pesado trabajo criptográfico para que usted pueda concentrarse en la lógica comercial de su aplicación.

Para continuar desarrollando su flujo de trabajo de documentos, explore estos temas relacionados:

• Cómo generar PDFs desde HTML en ASP.NET Core -- la base para la mayoría de los flujos de trabajo de firma
• Cómo agregar contraseñas y permisos a PDF : combine la firma con el cifrado para obtener la máxima seguridad
• Cómo fusionar y dividir archivos PDF : ensamblar paquetes de varios documentos antes de firmarlos
• Opciones de licencia de IronPDF : elija el plan que se adapte a su implementación
• Paquete NuGet IronPDF : consulte la última versión y el registro de cambios

Comienza con una prueba gratuita de IronPDF y ten tu primer PDF firmado en funcionamiento en menos de una hora. Si tiene preguntas o se encuentra con casos extremos, el equipo de soporte de Iron Software está disponible para ayudarlo a brindar un flujo de trabajo de firma de documentos confiable y que cumpla con las leyes.