Java security: If you ain’t cheatin,’ you ain’t tryin’
Vulnerabilities mentionedAll →
| CVE | Vulnerability | CVSS | EPSS | Flags | Affected | Exposure | Published |
|---|---|---|---|---|---|---|---|
| CVE-2021-44228 | JNDI Injection Remote Code Execution in Apache Log4j2 (Log4Shell) Apache Log4j2, an extremely widely used Java logging library, fails to protect its JNDI lookup feature against attacker-controlled JNDI-related endpoints (CWE-20, CWE-502), so crafted text processed by the logger causes the Java runtime to fetch and load attacker-supplied objects, leading to remote code execution. The flaw is triggered whenever attacker-controlled input reaches the logging API and is parsed for JNDI lookups, a pattern common in web servers and enterprise Java applications that log user-supplied fields such as headers or form values. Successful exploitation yields arbitrary code execution under the privileges of the affected application, giving attackers a foothold for lateral movement, data theft, and ransomware deployment. Any Java application or product that ships or bundles an affected Apache Log4j2 release is exposed, making this one of the most broadly deployed vulnerabilities ever disclosed. Exploitation is confirmed in the wild: CISA added it to the Known Exploited Vulnerabilities catalog on 2021-12-10 with known ransomware use, and EPSS assigns a 100% probability of exploitation within 30 days. Do: Inventory all Java applications and dependencies for Apache Log4j2 and apply the vendor's patched updates, or remove affected assets from the network, as required by CISA's KEV catalog. Where updates are not yet available, use the temporary mitigations in CISA's ED-22-02 recommended-mitigation guidance, such as disabling message lookups, only until patches are applied. Prioritize internet-facing and business-critical systems and hunt for exploitation activity given known ransomware use. | 10.0 | 100% | KEV ransomware PoC ×9 |
| masshundreds of millions of Java applications/devices, with hundreds of thousands of internet-exposed services |
Full article1,354 words · extracted from cyberscoop.com · click to collapse
Get our latest cybersecurity news first on Google.
Rigging the odds in your favor is the only way security practitioners can go.
Listen to this article
0:00
Learn more.
Most industries have rules of engagement. In sports, there are referees. In business, there are regulations. In government, there are Robert’s Rules of Order. Cybersecurity is different. There are regulations, but they don’t limit how much we can defend ourselves. They focus on compliance, breach reporting, and risk management, not on dictating the strategies we use to stop attackers. Meanwhile, attackers have no such constraints.
Sure, there are laws against hacking, but the rules of engagement don’t matter if your opponents toss the rule book out and rig the game. Attackers have no code of conduct telling them they can’t automate reconnaissance, exploit zero-days, or attack critical systems at 3 a.m. on Christmas morning. They don’t wait for compliance checks or budget approvals. They don’t play by the same rules we do, and they certainly aren’t waiting for defenders to catch up.
That’s the problem with the cybersecurity arms race — it’s a cycle that keeps reactive defenders one step behind active attackers. Detect, develop patch, deploy patch, repeat. We’re always addressing the last threat while attackers move on to the next one. Even red teams, whose job is to find vulnerabilities before attackers do, must play by the rules. There are certain business functions they simply aren’t allowed to interfere with.
Instead of reacting, defenders need to seize the initiative — to get ahead of the game and break the cycle. That means finding ways to cheat — stacking the deck in our favor with solutions that neutralize threats before they can be exploited.
The cybersecurity arms race is a rigged game
In cybersecurity, defenders have to be right 100% of the time, while attackers only need to get lucky once. That’s what makes defending Java applications such a daunting task. Java is the backbone of financial services, enterprise applications, and government infrastructure. It’s a massive attack surface with numerous avenues to open-source libraries. We can’t afford to secure such a complex system reactively.
Yet that’s exactly what most organizations do. Their security stack is built for a different era, a system of firewalls, WAFs, and endpoint detection that protects the perimeter while attackers slip through the cracks. Vulnerabilities exist in software dependencies, misconfigurations, and runtime behavior — things that traditional defenses were never designed to handle. Attackers don’t need to break through the front door if they can climb in through a window.
No real-world event exemplifies this better than the Log4j fiasco. When the Log4Shell vulnerability (CVE-2021-44228) was disclosed, security teams scrambled to patch it, knowing that delay meant exposure to mass exploitation. But patching takes time. Security teams had to test for compatibility, wait for scheduled downtime, and ensure business continuity. In the first week alone, there were over 840,000 exploit attempts recorded in the wild.
For attackers, Log4Shell was a gift — a free shot at thousands of unpatched, vulnerable systems. They didn’t have to wait for teams to patch. They didn’t have to deal with red tape. They just acted.
That’s why defenders need a new approach. The goal isn’t just to patch faster — it’s to stop playing by a rulebook that attackers have been ignoring for decades.
The best defenders steal the attacker’s playbook
Attackers don’t just look for known vulnerabilities. They look for opportunities — weak points in execution, dependencies, memory handling, and logic flaws. They take advantage of the fact that many security solutions are designed for detection rather than prevention.
The best defense isn’t just building a bigger wall — it’s changing the battlefield entirely. Attackers assume they’ll find a weakness because most defenses only react once something bad happens. What happens when they hit an environment where exploits fail before they even start?
By shifting from a reactive to an active security posture, defenders can dictate the terms of engagement, making it significantly more challenging for attackers to succeed.
Cybercriminals automate everything — scanning for weaknesses, testing exploits, even launching entire attack campaigns — because they know manual defenses are too slow to stop them. Defenders should be doing the same. And no, that doesn’t mean only adopting AI-powered security tools that try to “predict” attacks. A lot of security folks are (rightly) not comfortable allowing a fully autonomous system to make changes to their configuration without their knowledge. But automation doesn’t have to mean AI.
There’s a smarter way: immutable rules that neutralize vulnerabilities at runtime, before they can be exploited.
With the right security controls in place, an attacker might bypass a firewall, evade detection, and land inside an application. But once inside, they encounter a runtime environment that actively works against them — one that automatically neutralizes exploits, blocks malicious code execution, and prevents memory corruption attacks without requiring a patch, downtime, or human intervention. It’s not just an extra layer of defense. It’s a trap, designed to render an attacker’s efforts useless the moment they try to act.
Consider Star Trek II: The Wrath of Khan. In the movie, the Enterprise is caught off guard because it assumes the approaching starship Reliant is friendly. Khan uses this false sense of security to launch a devastating attack before Kirk and his crew can react. Cyberattacks work the same way — appearing legitimate until it’s too late. Attackers don’t always smash through defenses; they slip in unnoticed, exploiting trust and expected behaviors. A malicious request might look like a routine API call, a small memory overwrite could trigger a full system compromise, and a dependency update could introduce an unnoticed backdoor. If defenders only react after something goes wrong, they’re playing Khan’s game — outmaneuvered before the real fight even begins. The key to winning isn’t just detecting the attack. It’s designing an environment where the attack itself never works.
Change the game before the game changes you
Java security has spent the past two decades playing defense — patching vulnerabilities, filtering input, monitoring for suspicious activity. It isn’t designed for modern threats.
By the time a patch is released, tested, and deployed, attackers have already weaponized the vulnerability. Firewalls and WAFs protect the network, but attacks happen inside the app. Zero-days are always a problem because detection-based security will always be one step behind real-time threats.
Defending Java applications the same way we’ve been doing for 20 years is a losing strategy. The world has changed. Attackers have evolved. It’s time security evolved, too.
Cybercriminals aren’t playing fair. They automate reconnaissance, weaponize vulnerabilities instantly, and adapt their tactics faster than defenders can react.
So stop playing fair. Rewrite the rules. Automate. Cheat. Because in cybersecurity, the only way to win is to rig the odds in your favor. After all, who’s going to stop you?
Doug Ennis is the CEO of Waratek, a leader in securing Java applications.
Latest Podcasts
Government
Technology
Threats
Chinese espionage groups swarm to exploit triple-link chain of zero-days
Microsoft discloses two actively exploited zero-days among 974 vulnerabilities
Russian national extradited to US for alleged involvement in bank-account takeover scheme
Attackers exploit zero-days in consistently besieged SonicWall product
Policy
Whistleblower says USPS deploying new, ‘untested’ IT systems governing mail-in ballots
‘Watershed 250’ test program in Texas looks to private sector for water cybersecurity help
Former sexual abuse victims say Grok used their images, videos to train deepfake capabilities
Cyber threats nudge Trump to sign executive order on foreign equipment in U.S. energy infrastructure
Text extracted automatically; images, tables and formatting may be missing. Original: https://cyberscoop.com/java-applications-security-op-ed/