Popular with:
Security Engineer
Application Security

Safeguarding Against SSRF: Securing HTML to PDF Conversion

May 14, 2024
Written by
Abhishek P Dharani

Converting web pages to PDFs seems harmless, right? Unfortunately, if not done carefully, it can open the door to a nasty attack called Server-Side Request Forgery (SSRF). This happens when attackers trick your HTML-to-PDF converter into making sneaky requests that can expose sensitive data or even compromise your system.

In this blog post, we'll examine how SSRF attacks exploit HTML converters and what you can do to stop them. We'll focus on secure coding practices and techniques like sanitizing HTML input to make sure your web applications stay safe.

Understanding SSRF Vulnerabilities

SSRF is a type of vulnerability that allows attackers to manipulate a server into making unintended requests on their behalf. By exploiting SSRF vulnerabilities, attackers can interact with internal systems, access sensitive data, or execute arbitrary code on the server. Such attacks bypass traditional security measures, posing a severe threat to web applications and their users.

The Risks of HTML to PDF Conversion

HTML to PDF conversion libraries, such as wkhtmltopdf, play a crucial role in generating PDF documents from HTML content. However, if not properly configured, these libraries can inadvertently expose SSRF vulnerabilities. Attackers can exploit this functionality to trigger SSRF attacks by injecting malicious URLs or payloads into the conversion process.

Identifying Misconfigurations

Consider a scenario where a web application utilizes wkhtmltopdf for HTML to PDF conversion. Without proper validation and sanitization, the application may render unsafe HTML content, thereby exposing itself to SSRF vulnerabilities. Below is a simplified Python code snippet illustrating this scenario:

import wkhtmltopdf

def convert_to_pdf(html_content):
    pdf = wkhtmltopdf.from_string(html_content, 'output.pdf')

In this code, the convert_to_pdf function accepts HTML content as input and passes it directly to wkhtmltopdf.from_string for conversion. If the input HTML contains unsafe elements or scripts, it can potentially trigger SSRF attacks during the conversion process.

Mitigating SSRF Risks and Rendering Safe HTML

To mitigate SSRF risks associated with HTML to PDF conversion, it's crucial to implement proper input validation, sanitization, and rendering of safe HTML content. Below are some preventive measures:

  • Input Validation: Validate input HTML content to ensure it adheres to expected formats and does not contain any malicious elements or scripts. Consider using libraries like bleach to sanitize HTML content and remove unsafe elements.
  • Safe Rendering Options: Configure the HTML to PDF conversion library to render HTML content in a secure manner, without executing JavaScript or accessing external resources. Utilize options such as --disable-javascript and --no-images to disable JavaScript execution and image loading during conversion.
  • Content Security Policy (CSP): Implement CSP headers to restrict the sources from which the HTML content can load external resources. By specifying trusted domains and enforcing strict content security policies, you can prevent unauthorized requests and mitigate SSRF risks.

Here's an updated version of the convert_to_pdf function incorporating these measures:

import bleach

def convert_to_pdf(html_content):
    sanitized_html = bleach.clean(html_content, tags=[], attributes={}, strip=True)
    pdf = wkhtmltopdf.from_string(sanitized_html, 'output.pdf', options={'--disable-javascript', '--disable-local-file-access'})

To render safe HTML content, integrate HTML sanitization into the conversion process. Python offers libraries like bleach for this purpose.

Why do we use the options mentioned below?

options={'--disable-javascript', '--disable-local-file-access'}: These are options passed to the wkhtmltopdf library. In this case, two options are specified:

--disable-javascript: This option disables JavaScript execution during the conversion process. Disabling JavaScript helps to mitigate security risks associated with XSS (Cross-Site Scripting) attacks and prevents any potentially malicious JavaScript code from being executed.

--disable-local-file-access: This option disables access to local files during the conversion process. It prevents the HTML-to-PDF converter from accessing files on the local file system, which helps to mitigate security risks such as SSRF (Server-Side Request Forgery) attacks and LFI( Local File Inclusion), where an attacker might attempt to access sensitive files or resources on the server.

By enforcing proper input validation, sanitization, and rendering of safe HTML content, developers can significantly reduce the risk of SSRF vulnerabilities stemming from misconfigured HTML to PDF conversion modules.

Preventing Cloud Metadata Extraction SSRF

Another critical aspect to consider is the prevention of Cloud Metadata Extraction SSRF attacks. Attackers can exploit SSRF vulnerabilities to extract sensitive metadata from cloud resources. To mitigate this risk:

  • Restrict Access to Cloud Metadata ( Configure network-level restrictions to prevent access to cloud metadata endpoints from within the application.

  • Implement Request Whitelisting: Implement strict whitelisting of allowed URLs and IP addresses to further restrict access and prevent unauthorized requests.


In today's threat landscape, securing web applications against SSRF vulnerabilities is paramount. Misconfigured HTML to PDF conversion modules can inadvertently expose applications to SSRF attacks, posing significant risks to data security and integrity. However, by implementing rigorous input validation, sanitization, and rendering of safe HTML content, developers can mitigate these risks and ensure robust security posture. Remember, proactive security measures are essential for safeguarding against emerging threats and maintaining the trust of users in the digital ecosystem.


Owning the clout through SSRF and PDF generators - Public v1.0

Source for article
Abhishek P Dharani

Abhishek P Dharani

Abhishek P Dharani is a Senior Security Engineer at we45. Abhishek P Dharani is a self taught security engineer with a keen interest in application security and automation. He is enthusiastic about both offensive and defensive security strategies. With a keen eye for vulnerabilities, he immerses himself in constantly honing his skills to stay ahead in the cybersecurity game. Adept at both cricket and badminton, Abhishek finds solace in the competitive spirit of sports. When he's not on the field, you'll likely find him at the bowling alley, enjoying the precision and strategy required to hit that perfect strike.

Abhishek P Dharani


Contact Support


1603 Capitol Avenue,
Suite 413A #2898,
Cheyenne, Wyoming 82001,
United States

Copyright AppSecEngineer © 2023