Description

Frappe Framework development builds contain an authorization flaw in the render_jinja_template endpoint that allows low-privileged users to render arbitrary Jinja templates by supplying raw template strings. Attackers with print permission on any document can execute arbitrary SELECT statements against unrelated tables, including reading password hashes from the __Auth table.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "6.5",
  "pubDate": "2026-08-30T13:16:56.780Z",
  "pubdate": "2026-08-30T13:16:56.780Z",
  "executiveSummary": "The Frappe Framework is susceptible to a critical Server-Side Template Injection (SSTI) vulnerability located within the render_jinja_template endpoint. This security flaw stems from insufficient input sanitization, which permits unauthorized users to inject and execute arbitrary Jinja2 template syntax. The vulnerability allows an attacker to bypass standard access controls, facilitating unauthorized database interactions and unauthorized data extraction.\nThe impact of this vulnerability is severe, as it enables low-privileged users—specifically those possessing 'print' permissions—to execute arbitrary SQL SELECT statements against the underlying database. This capability extends to sensitive system tables, including the '__Auth' table, potentially leading to the compromise of password hashes and other confidential information. The exploit does not require administrative privileges, significantly increasing the attack surface within an organization. Remediation requires strict input validation and the implementation of hardened template rendering policies to prevent untrusted code execution.",
  "technicalDetails": "The vulnerability resides within the 'render_jinja_template' endpoint of the Frappe Framework. The root cause is an insecure implementation of server-side template processing where user-supplied raw strings are passed directly to the Jinja2 engine without adequate validation or sandboxing. This allows for the injection of template expressions that are executed in the context of the server application.\nThe attack flow begins when an authenticated user with 'print' permissions interacts with the vulnerable endpoint. By crafting a specific HTTP request, an attacker can supply malicious template code as input. Because the framework fails to restrict the environment variables or the context available to the Jinja2 renderer, the attacker can leverage framework-provided functions or objects to interact with the database layer.\nSpecifically, the attacker can invoke database abstraction layer functions available within the template context to execute arbitrary SELECT queries. By manipulating the template logic, an attacker can bypass the intended query restrictions. This allows the attacker to query tables that are otherwise restricted, such as the '__Auth' table, which typically stores hashed credentials. The payload behaves by coercing the server to perform unauthorized read operations and returning the resulting data back to the user through the rendered template response.\nThe exploitation process is as follows: 1) The attacker identifies the target endpoint, 'render_jinja_template'. 2) The attacker authenticates as a user with at least 'print' permissions. 3) The attacker submits a carefully crafted template payload containing Jinja2 syntax designed to interface with the database. 4) The server processes the template, executing the injected SQL commands. 5) The sensitive data retrieved from the database, such as hashes from '__Auth', is included in the template output and returned to the attacker. Post-exploitation impact includes full credential harvesting, potential lateral movement, and complete compromise of the underlying data store due to the ability to extract sensitive internal records."
}