wkhtmltopdf vs IronPDF: Leitfaden für einen technischen Vergleich

Die Sicherheitskrise CVE-2022-35583

Die Server-Side Request Forgery (SSRF)-Schwachstelle in wkhtmltopdf ermöglicht es Angreifern,:

• Zugriff auf interne Dienste: Erreichen Sie interne APIs, Datenbanken und Dienste hinter Firewalls
• Zugangsdaten stehlen: Zugriff auf Cloud-Metadatenendpunkte (AWS, GCP, Azure) zum Diebstahl von IAM-Zugangsdaten
• Port-Scanning: Scannen interner Netzwerke innerhalb der Infrastruktur
• Datenexfiltration: Extrahieren sensibler Daten durch speziell präpariertes HTML/CSS

Der Angriffsvektor ist einfach: bösartiges HTML, das an einen PDF-Generator übermittelt wird:

<!-- Malicious HTML submitted to your PDF generator -->
<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>

<!-- Malicious HTML submitted to your PDF generator -->
<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>

Wenn wkhtmltopdf dieses HTML rendert, holt es diese URLs aus dem Netzwerkkontext des Servers und umgeht dabei Firewalls und Sicherheitskontrollen. Diese Schwachstelle wird nie gepatcht werden, da das Projekt offiziell aufgegeben wurde.

Betroffene Wrapper-Bibliotheken

Alle .NET-Wrapper für wkhtmltopdf erben die gleichen Schwachstellen:

Wenn Ihre Anwendung eine dieser Bibliotheken verwendet, ist sie anfällig für CVE-2022-35583.

wkhtmltopdf Konfigurationsmuster

wkhtmltopdf-Wrapper erfordern die Erstellung von Dokumentobjekten mit verschachtelten Einstellungskonfigurationen:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

Dieses Muster erfordert die Erstellung eines SynchronizedConvertermit PdfTools, die Konstruktion eines HtmlToPdfDocumentmit GlobalSettings und Objects Sammlungen und das manuelle Schreiben von Byte-Arrays in Dateien.

IronPDFVereinfachtes Muster

IronPDF verwendet einen schlanken Ansatz mit der Klasse ChromePdfRenderer:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}

Die Klasse ChromePdfRenderer beseitigt die verschachtelten Konfigurationsobjekte und liefert ein PdfDocument mit integrierten Speichermethoden. Eine umfassende Anleitung zur HTML-Konvertierung finden Sie im HTML to PDF tutorial.

wkhtmltopdf Implementierung

wkhtmltopdf verwendet die Eigenschaft Page innerhalb von ObjectSettings, um URLs anzugeben:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

IronPDFImplementierung

IronPDF bietet eine eigene RenderUrlAsPdf-Methode:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Die RenderUrlAsPdf-Methode nutzt die Chromium-Engine, um Seiten mit vollständiger JavaScript-Ausführung und moderner CSS-Unterstützung zu rendern - Fähigkeiten, die durch die 2015er WebKit-Engine von IronPdf eingeschränkt sind.

wkhtmltopdf Benutzerdefinierte Einstellungen

wkhtmltopdf benötigt verschachtelte GlobalSettings mit MarginSettings Objekten:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}

IronPDFBenutzerdefinierte Einstellungen

IronPDF verwendet RenderingOptions-Eigenschaften für die direkte Konfiguration:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}

CLI-zu-C#-API-Zuordnung

C# Wrapper API-Mapping

Platzhalter-Syntax-Zuordnung

Anforderungen an die Sicherheit

Organisationen, die Sicherheitsanforderungen erfüllen müssen (SOC 2, PCI DSS, HIPAA), können keine Anwendungen mit bekannten kritischen Schwachstellen akzeptieren. Der Schweregrad 9.8 von CVE-2022-35583 löst in den meisten Sicherheits-Frameworks sofortige Behebungsanforderungen aus.

Moderne CSS-Framework-Übernahme

Teams, die Bootstrap 5, Tailwind CSS oder benutzerdefinierte CSS-Grid-Layouts verwenden, stellen fest, dass wkhtmltopdf diese nicht korrekt darstellen kann. Der WebKit-Engine von 2015 fehlt die Unterstützung für CSS-Gitter vollständig und die Flexbox-Implementierung ist nicht mehr vorhanden.

JavaScript-Anwendungsanforderungen

Anwendungen, die moderne JavaScript-Funktionen verwenden - ES6+-Syntax einschließlich Pfeilfunktionen, async/await, Klassen und Template-Literalen - werden in wkhtmltopdf nicht funktionieren. Die Chromium-Engine vonIronPDFbietet vollständige JavaScript-Unterstützung.

Cloud- und Container-Einsätze

Moderne Bereitstellungsstrategien, die Docker, Kubernetes oder Cloud-Plattformen verwenden, profitieren von der containerfreundlichen Architektur von IronPDF. Sicherheitsscans von wkhtmltopdf-Binärdateien in Containern werden die CVE-Schwachstelle aufzeigen.

Langfristige Wartungsfragen

Da für wkhtmltopdf keine zukünftigen Updates zu erwarten sind, sehen sich die Teams mit zunehmenden technischen Schulden konfrontiert, da sich die Webstandards weiterentwickeln. Die aktive Entwicklung vonIronPDFgewährleistet die kontinuierliche Kompatibilität mit zukünftigen .NET-Versionen, einschließlich .NET 10, das für 2026 erwartet wird.

Async-Unterstützung

IronPDF bietet async/await-Unterstützung für die Leistung von Webanwendungen:

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

Dies verhindert das Blockieren von Threads in hochbelasteten Webanwendungen - eine Fähigkeit, die mit den nur synchronen Wrappern von wkhtmltopdf nicht verfügbar ist.