Smarty Security stream restriction bypass through stream: resource
smarty/smarty version 5.8.0 can read local files through PHP stream wrappers even when Smarty Security is enabled and all streams are disabled with Security::$streams = null.
The bypass uses Smarty's built-in stream: resource type. A template such as:
```smarty
{include file="stream:php://filter/read=convert.base64-encode/resource=/tmp/secret.tpl"}
```
is handled as Smarty resource type stream, so the security check that would normally reject the underlying php wrapper is not applied. StreamPlugin then opens the nested php://filter/... URI directly.
For comparison, the direct resource:
```smarty
{include file="php://filter/read=convert.base64-encode/resource=/tmp/secret.tpl"}
```
is blocked with stream 'php' not allowed by security setting.
Affected package:
- Ecosystem: Packagist / Composer
- Package:
smarty/smarty - Confirmed affected version:
5.8.0 - Confirmed source reference from Composer lock:
78d259d3b971c59a0cd719c270cc5cbb740c36a7 - Current stable version on Packagist at review time:
v5.8.0 - Packagist usage at review time: 41,113,855 total downloads and 840,604 monthly downloads
Relevant code paths:
Smarty\Resource\BasePlugin::load(...)Smarty\Resource\StreamPlugin::getContent(...)Smarty\Security::isTrustedStream(...)
BasePlugin::load() maps the built-in resource name stream directly to StreamPlugin before the code path that checks PHP stream wrappers with stream_get_wrappers() and Security::isTrustedStream($type). StreamPlugin::getContent() later calls fopen($filepath, 'r+') on the nested URI when the resource name contains ://.
Preconditions:
An application must render templates that are not fully trusted while relying on Smarty Security to restrict local files and PHP stream wrappers. The PoC sets:
```php
$smarty->enableSecurity();
$smarty->security_policy->streams = null;
```
Local reproduction:
The PoC creates a disposable template directory and a separate outside directory. It enables Smarty Security, disables all streams, and then compares three includes:
1. ../outside/secret.tpl to confirm the ordinary trusted-directory boundary is enforced.
2. php://filter/... to confirm direct PHP streams are blocked by Security::$streams = null.
3. stream:php://filter/... to show the built-in stream: resource bypasses the same restriction and reads the outside file.
Run:
```shell
php -d display_errors=1 poc.php
```
Observed sanitized output:
```text
package=smarty/smarty
installed_version=v5.8.0
template_dir=<tmp>/templates
outside_template=<tmp>/outside/secret.tpl
plain_dotdot_include=BLOCKED:Smarty\Exception:Smarty Security: not trusted file path '<tmp>/outside/secret.tpl'
direct_php_filter_include=BLOCKED:Smarty\Exception:stream 'php' not allowed by security setting
stream_php_filter_include=OK:U01BUlRZX1NUUkVBTV9XUkFQUEVSX1NFQ1VSSVRZX0VTQ0FQRQ==
expected_base64=U01BUlRZX1NUUkVBTV9XUkFQUEVSX1NFQ1VSSVRZX0VTQ0FQRQ==
```
The plain_dotdot_include line shows the directory boundary is enforced for ordinary traversal. The direct_php_filter_include line shows the same policy rejects php://filter when used directly. The stream_php_filter_include line shows that wrapping the same URI in Smarty's stream: resource bypasses that restriction and reads the outside file.
Impact:
A template author can bypass Smarty Security stream restrictions and read local files that are readable by the PHP process. With php://filter, file contents can be base64 encoded and rendered back through the template. This bypasses both the intended Security::$streams = null restriction and the normal trusted-template-directory check that blocks ../ traversal.
Duplicate checks:
- OSV query for
Packagist/smarty/smarty version 5.8.0 returned no vulnerabilities. - GitHub advisory query for
ecosystem=composer and affects=smarty/smarty returned historical Smarty advisories, including sandbox escapes, PHP code injection, XSS, and older path traversal issues. The listed path traversal advisories affect older versions and do not describe this current stream:php://filter resource-wrapper bypass in 5.8.0. - GitHub issue search in
smarty-php/smarty for stream:php://filter returned zero results. - Public searches for
Smarty StreamPlugin php://filter and smarty/smarty isTrustedStream stream: did not identify a clear public duplicate during triage.
Suggested remediation:
When resolving the built-in stream: resource, parse and validate the nested URI scheme before opening it. For example, stream:php://filter/... should call Security::isTrustedStream('php'), and Security::$streams = null should block the resource before StreamPlugin::getContent() reaches fopen().
It would also be safer for StreamPlugin to reject nested stream wrappers by default unless the underlying wrapper is explicitly allowed by the active security policy.
