
Stay secure. And bring VIDOC into your development workflow ;) vidocsecurity.com/

Securing how the world builds software

Stay secure. And bring VIDOC into your development workflow ;) vidocsecurity.com/

What should you do? → Check your Java runtime versions and whether your systems use x86-64 processors supporting AVX-512 VBMI. → Update affected Java runtimes to patched versions, including those bundled with applications. → If you can't patch immediately, temporarily disable the vulnerable Base64 optimization using XX:-UseBASE64Intrinsics and restart the JVM.

🚨 Critical Java vulnerability Found with AI in one hour. Two more hours to build a working exploit. Less than $200 in AI tokens. Researchers at Calif disclosed Java4Shell (CVE-2026-114938), a critical OpenJDK vulnerability with a CVSS score estimated at 9.2 out of 10. The bug lives in Java's Base64 decoder, where a specially crafted 65-character input can trigger memory corruption and potentially lead to remote code execution.

Your password is incorrect. Please add more characters.
The bug is like a joke. On Alpine Linux, type 257 to 1024 characters of anything and you get root. 💀

How much does it cost to scan the entire PHP codebase with AI? @gregxsunday tested 6 frontier models and calculated the projected cost of a full scan based on our results. The cheapest: DeepSeek V4.1 Flash at ~$800. The most expensive: Claude Opus 5.5 at ~$18,200. That's over a 22x difference for a single scan. Full breakdown in our recent article.

.@gregxsunday tested 6 AI models on PHP2Shell. GPT-5.6 Sol: 11.7 findings, 1 related ($23.63/run) Gemini 4 Argon: 5.3 findings, 1.3 related ($14.06/run) Opus 5.5: 0 related ($33.87/run) Estimated cost to scan the entire PHP codebase - $800-$18,200. Full results in our recent article.

Last week's PHP2Shell vulnerability was discovered through OpenAI's Patch the Planet initiative. But can you really find critical bugs just by asking an LLM? We tested six frontier models on vulnerable PHP code to see what they'd catch and at what cost.


GLM 5.3 is dangerous... dangerously good for cybersecurity; great at reversing, finding bugs, and creating exploits This is why we are giving it away for free to the security community! No guardrails, no refusals If you are a defender and want to get more tokens, please reach out! model.vidocsecurity.com/

This is VIDOC. Anything your security engineer can do on a computer, VIDOC can do for you. Fast.

Our harness discovered multiple 0-days in networking stack of Linux Kernel (using publicly accessible LLMs) This is one of many CVEs to come Thank you @GuanniQu for great collaboration!!
found a remotely triggerable out-of-bounds read in the Linux kernel's H.323 connection tracking parser (CVE-2026-23456, CVSS 8.2). no authentication. no privileges. no user interaction. send a malformed packet to port 1720 on any Linux firewall or NAT gateway running nf_conntrack_h323 and you're reading kernel slab memory. some context on why this matters more than a typical kernel OOB. H.323 is a VoIP signaling protocol from the 1990s. it is everywhere you don't think to look. telecom carriers, enterprise PBXs, session border controllers, hospital phone systems, building intercoms, elevator emergency phones, legacy videoconferencing. every Linux-based firewall or NAT device that needs to track H.323 connections for dynamic port allocation loads nf_conntrack_h323, which contains a full ASN.1 PER decoder running inline in the kernel, parsing untrusted data from the network, at wire speed, with direct access to kernel memory. this module auto-loads when H.323 traffic hits a conntrack rule. on many distributions it's loaded by default. the attack surface is: send a packet from the internet to a machine that might be doing NAT for a phone system somewhere behind it. the bug. in decode_int(), the CONS case: nf_h323_error_boundary(bs, 0, 2) len = get_bits(bs, 2) + 1 BYTE_ALIGN(bs) v = get_uint(bs, len) the boundary check validates 2 bits for get_bits(). it does not validate len bytes for get_uint(). the length field is bounds-checked. the data described by the length field is not. craft a H.323/RAS packet where the bitstream is truncated after the length field. get_uint() walks 1–4 bytes off the end of a slab allocation. the attacker controls which allocation this is and can potentially influence what's adjacent in the slab cache. 1–4 bytes doesn't sound like much until you remember that kernel pointers, ASLR secrets, and crypto material all live in slab memory and a single leaked pointer can defeat KASLR. now the interesting part. after the patch landed, Jakub Kicinski's AI code reviewer flagged five other locations in the same file as having the same bug: UNCO in decode_int, SEMI in decode_bitstr, SEMI and default in decode_octstr, BYTE in decode_bmpstr. all five advance bs->cur without checking that enough bytes remain. Florian went through each one and found a post-advance boundary check after every single one. "this LLM response is bunk." he was right. but the reason he was right is the reason the CONS case is a real bug and the other five are not, and I think this is where current AI code review genuinely cannot tell the difference. the other cases do this: advance bs->cur past the data without dereferencing, then check nf_h323_error_boundary(bs, 0, 0) after the switch block. the pointer overshoots. nothing reads through it. the boundary check fires. the function returns an error. pointer arithmetic past the end of a buffer is not a memory safety violation, only pointer dereference is. the pointer moved into illegal territory but nobody looked through the window. the CONS case is different. get_uint(bs, len) dereferences *bs->cur++ inline. it reads 1–4 bytes from memory as part of advancing. the dereference and the advance are the same operation. there is no "temporary overshoot" because the bytes are physically read from memory during the overshoot. a post-advance boundary check cannot un-read memory. the AI saw "pointer advances without pre-check" six times and pattern-matched all of them as the same bug. five of them advance a pointer. one of them reads through a pointer while advancing. pointer arithmetic vs pointer dereference is the entire vulnerability, and current AI review can't see the difference because it's matching on control flow shape, not on what the CPU actually does when the instruction executes. the fix is two lines. one call to nf_h323_error_boundary(bs, len, 0) between get_bits() and get_uint(). the original commit is 5e35941d9901, "[NETFILTER]: Add H.323 conntrack/NAT helper", from 2007. twenty years of a full ASN.1 decoder running in kernel space, parsing untrusted packets from the network, with a missing bounds check on a length-prefixed read. loaded by default on most distributions. reachable without authentication. the fix is two lines. reported by Klaudia Kloc and Dawid Moczadło from @VidocSecurity. I verified the bug, wrote the PoC, and submitted the patch. patched in stable 5.10–6.19.

Attackers won't wait. Full breakdown of what we ran, how and what it means for defenders ↓ blog.vidocsecurity.com/blog/…

$30 That's what it cost us to reproduce Anthropic's Mythos findings, FreeBSD, OpenBSD, FFmpeg using GPT 5.4 by OpenAI and other public models in an open-source harness. The economics of vulnerability discovery are shifting fast. The moat isn't model access anymore - it's validation. Finding vuln signal is getting cheap, but turning it into trusted security workflow is still hard. Thanks OpenAI for Devs!

Mythos myth is busted. We reproduced Anthropic’s public Mythos examples of vulnerabilities in FreeBSD, OpenBSD, FFmpeg, using GPT-5.4 and Claude Opus 4.6. We reproduced every public example we tested with at least one widely available model. Message to defenders: attackers won’t wait. The challenge is using these models to detect and patch vulnerabilities before bad guys do, in real production environment, at scale. Co-authors: @kannthu @AmadeuszL Marek Lewandowski, Kuba Sienkiewicz, Mikołaj Palkiewicz

We replicated Mythos findings in opencode using public models, not Anthropic's private stack. The moat is moving from model access to validation: finding vulnerability signal is getting cheaper; turning it into trusted security A better way to read Anthropic's Mythos release is not "one lab has a magical model." It is: the economics of vulnerability discovery are changing. We took the patched public Mythos examples and tried to reproduce them with GPT-5.4 and Claude Opus 4.6 in an open-source harness. Every run stayed below $30 per file. AI models are already good enough to narrow the search space, surface real leads, and sometimes recover the full root cause in battle-tested code. The takeaway: model access is not the moat anymore. Validation is. Finding vulnerability signal is getting cheaper; turning it into trusted security work is still hard. Co-authors: @KlaKlo_, Amadeusz, Marek, Kuba, Mikolaj
UPDATE: We were able to replicate the Mythos findings using existing models (GPT5.4) Writeup coming early next week, no BS prompts, it's real reproduction

Our take on that → blog.vidocsecurity.com/blog/…

AI exposed that we’ve been sitting on critical vulnerabilities for years. Claude Mythos found a 27-year-old OpenBSD bug and a 16-year-old FFmpeg flaw. But it didn’t create state-level hackers. What changed is the economics: → Exploit development is now cheap → Scalable → And fast enough to matter