# Common-sense security hardening for the next PHP

- Thread: https://externals.io/message/133164
- Original archive: https://news-web.php.net/php.internals/133164
- Started by Craig Francis on 2026-11-21T10:43:03+00:00
- Messages: 1
- RFC: Is literal (Declined) — https://externals.io/rfc/is_literal.md
- Reply by email to internals@lists.php.net
- More for agents: search with https://externals.io/search.md?q={query} · RFCs at https://externals.io/rfc.md · JSON API at https://externals.io/api · documentation at https://externals.io/llms.txt

---

## #133164 — Craig Francis — 2026-11-21T10:43:03+00:00

URL: https://externals.io/message/133164#133164

> [...] I take back about $interpolation inside <<<PHP et al. ... We may
> need some new syntax like <<<<PHP, which treats $foo and {$foo}
> differently.
>
> But the bigger point is — if we can get PHP 9 to simply close all the
> holes separating *developer-written code* from *dynamically constructed
> strings*, we’ll finally prevent a huge class of attacker-controlled
> arbitrary RCE.
>


You can do this today, use the `literal-string` type in Psalm and PHPStan;
unfortunately the vast majority of developers will never use static
analysis tools.

It addresses the taint-checking/escaping issues, it works for database
abstractions like Doctrine `where('u.id = ' . $_GET['id'])`, it doesn't
require everyone to rewrite their code to use something like Heredoc, and
you can concatenate `literal-string` values together (this really helps
adoption).

Christoph Kern did a lot of work in this area, Mike Samuel summarised it as
"Distinguish strings from a trusted developer, from strings that may be
attacker controlled", and Erik Poll wrote this paper:

https://www.cs.ru.nl/~erikpoll/papers/secure_input_handling.pdf

Or this summary I put together:

https://eiv.dev/

Unfortunately, when I put this forward, it was rejected:

https://wiki.php.net/rfc/is_literal

After the vote a couple of people said they wanted it to be implemented as
a type as well (when I've got some more time/money I'll finish this);
otherwise it seemed that most people were concerned about the length of the
discussion, a naming mistake, and voting closed a day before the 8.1
deadline.

That said, Python already has the LiteralString type; Go can use an
"un-exported string type" (string must be in the compiled code); C++ can
use a "consteval annotation"; C# can use a "ConstantExpected annotation"; Scala
can use "String with Singleton"; Java can use a @CompileTimeConstant
annotation from ErrorProne; Rust can use a "procedural macro"; and Node can
use goog.string.Const in Google's Closure Library.

Craig
