SSTI testing that proves code execution
Server-side template injection (SSTI) is when user input reaches a server-side template engine (Jinja2, Twig, Freemarker, Handlebars) and gets evaluated as template code — frequently a straight path to remote code execution. Sintropyc tests every input that lands in a template and proves each finding with a controlled evaluation, never a reflected string.
How SSTI becomes RCE
Template engines are meant to render data into a page. If attacker input is concatenated into the template itself rather than passed as data, the engine evaluates it — arithmetic first, then object access, then, in many engines, arbitrary code.
{{7*7}}renders as49— the tell-tale sign the input is evaluated, not printed- From there: reading server objects, config and environment
- In common engines (Jinja2, Freemarker, Velocity): full command execution
- Even 'sandboxed' template modes are frequently escapable
Where SSTI hides
Anywhere user input is folded into a rendered template: email and notification templates, customizable dashboards or reports, PDF and label generators, error pages, CMS blocks, and 'white-label' features that let a customer template their own content.
The rule is simple and the bug is common: pass user input as template data, never build the template string from it. Sintropyc finds the places that break the rule.
How Sintropyc tests it
Sintropyc is an autonomous AI penetration testing agent. It signs in as real users across different roles, drives your product the way a customer would, and proves every finding with a working exploit — never a scanner guess. Each finding is checked by a human before it reaches you, comes with the exact fix, and is attacked again after you ship it to confirm it held.
For SSTI, Sintropyc sends engine-specific probes into template-rendered inputs, first confirming evaluation with a benign arithmetic oracle (a {{7*7}}-style check), then, only as far as safe, demonstrating the reachable impact — object and config access — as proof. It reports SSTI only when the engine actually evaluated the input, with the exact probe and result.
What you get
- Every template-rendered input tested across engines
- Each finding proven by controlled evaluation, escalated only as far as safe
- The fix (data-not-template, sandbox, allow-list) per finding
- A retest after you ship it
Common questions
Is a {{7*7}}=49 result enough to report?
It's the confirmation the input is evaluated — the core of the proof. Sintropyc then assesses how far it reaches (config, objects, commands) with the smallest safe evidence, so severity matches real impact.
Will you run commands on our server?
Only with your explicit go-ahead, and then the smallest safe proof (an echo / whoami-style marker), never destructive actions or downloads.
Which engines do you cover?
The common server-side ones — Jinja2, Twig, Freemarker, Velocity, Handlebars, ERB and similar — with engine-specific probes rather than generic guesses.