Some unverified sources have said it's in the Base64 decoder, but strangely only effecting AMD64 machines, so anything on ARM/graviton allegedly isn't impacted. Some sort of bug in some hyper-optimized code I reckon. That might mean any place that parses cookies, headers, urls, JWTs, SAML payloads, certificates, etc, might be exposed. Yikes.
But the facts aren't really out yet, we'll learn more in coming hours and days...
There are only a bunch of commits that came in the latest merge of security fixes, and this one changed VBMI-related intrinsics code, so it's a good match for what was publicly disclosed at the time.
import java.util.Arrays;
import java.util.Base64;
public class Canary {
// static fields defeat escape analysis so dst/canary really live in the heap
static byte[] dst;
static byte[] canary;
public static void main(String[] args) {
// (input, expected decodedOutLength) pairs:
// 65 = "A"*64 + "=" -> fragment "=" (length 1, trailing pad)
// 66 = "A"*64 + "Q=" -> fragment "Q=" (length 2, trailing pad)
// 67 = "A"*64 + "QQ=" -> fragment "QQ=" (length 3, trailing pad)
// 68 = "A"*64 + "QQ==" -> fragment 4 bytes, well-formed control case
int[][] cases = { { 65, 50 }, { 66, 50 }, { 67, 50 }, { 68, 49 } };
byte[][] srcs = new byte[cases.length][];
for (int c = 0; c < cases.length; c++) {
int len = cases[c][0];
byte[] src = new byte[len];
Arrays.fill(src, (byte) 'A');
if (len == 65) { src[64] = '='; }
if (len == 66) { src[64] = 'Q'; src[65] = '='; }
if (len == 67) { src[64] = 'Q'; src[65] = 'Q'; src[66] = '='; }
if (len == 68) { src[64] = 'Q'; src[65] = 'Q'; src[66] = '=';
src[67] = '='; }
srcs[c] = src;
}
int iters = 300_000;
for (int iter = 0; iter < iters; iter++) {
for (int c = 0; c < cases.length; c++) {
byte[] src = srcs[c];
int dstLen = cases[c][1];
// fresh dst, then canary IMMEDIATELY after it in the TLAB
dst = new byte[dstLen];
canary = new byte[64];
Arrays.fill(canary, (byte) 0x41);
int before = canary.length;
try {
Base64.getDecoder().decode(src, dst);
} catch (IllegalArgumentException e) {
// expected for the malformed tails
}
if (canary.length != before || changed(canary)) {
System.out.println(
"*** ITERATION " + iter + ", input length " + src.length
+ ": DESTINATION BUFFER OVERRUN DETECTED");
System.out.println(
"canary.length = " + canary.length + " (expected 64)");
System.out.println(
"canary bytes = " + toHex(canary, 48));
return;
}
}
if (iter % 50_000 == 0)
System.out.println("iter " + iter + ": clean so far");
}
System.out.println(
"no corruption detected in " + iters + " iterations");
}
static boolean changed(byte[] b) {
for (byte x : b) if (x != 0x41) return true;
return false;
}
static String toHex(byte[] b, int n) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 64; i++)
sb.append(String.format("%02x ", b[i]));
return sb.toString();
}
}
I had to fix toHex() not to use b.length, otherwise it wouldn't print anything due to the negative array length field.
GLM had web access for this, and it was able retrieve the OpenJDK fix. I don't know if it found the reproducer in its web searches.
Turning this into a reliable exploit probably still requires some expertise. It's going to depend on heap layout at the time of the overflow. Targets won't be auto-selecting themselves like they did for Log4Shell.
Unconfirmed, but people on Twitter suggest this vulnerability has to do with the AVX512 implementation of Base64 decoding, and so this vulnerability can be worked around by running Java with the -XX:UseAVX=2 flag. (https://x.com/sean_a_cassidy/status/2122791344573976817)
There are presumably more bugs lurking in the hand crafted assembly intrinsics in the JVM. The many eyeballs and shallow bugs thing is only true when the eyeballs actually understand the code.
There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.
Edit: If I understood the article correctly, the machine needs to have all the four of these flags in order to be exploitable: avx512f, avx512bw, avx512vbmi, bmi2
I assume that the advice is referring to situations where you might have a mixture of ARM and AMD64 hosts, like on AWS, so you need to be careful about global flag updates that might not work across all instances.
It's possible if you have enough abstraction layers. At my company there are a few systems with Java runtime flags specified in the service source code, but deployment configuration in a separate infrastructure-as-code repository. Switching between CPU architectures is normally transparent if you don't rely on native code libraries.
I think the idea is that you’re already running the appropriate JVM on each architecture, but want to push a global command line flag update to every JVM you run, regardless of architecture, that prevents this exploit.
Until, presumably, there’s fixes and you can test, update etc.
I don't know if I'd count paving over the reality of what you're running with an abstraction layer as something simpler. If anything it demonstrably makes addressing issues like these harder.
I think you're right, but many people are running systems at large scale, with lots of hosts and all kinds of abstraction layers and stuff. Now this exploit shows up. What are they to do? It's just a practical thing they can do right now.
First we must stop the bleeding. After that, yes, it's worth figuring out if they should change how things are set up.
I've been in situations like this before. Sometimes the complications and abstractions were my fault, sometimes I inherited them. Either way, as responsible owners of the overall system or business, we've gotta be able to respond fast to issues.
Whenever I see code like this, I am always struck by how there are two types of programmers—those like me, and those who can work on whatever the hell that is.
I realize that speeding up Java's base64 w/ SIMD probably has a measurable impact on a significant proportion of all webservers everywhere. But at the same time, implementing the entire thing in ASM, by hand, looks ... rough. Here's the comment describing how it works:
What’s that old Chinese proverb? “May you live in interesting times”? It feels like we’re living in interesting times. How long will it take for a bad actor to seriously compromise critical infrastructure? My bet is within six months.
The upside is that it’ll force legacy institutions and organizations with sub-par security to get good at security and modernize their legacy stacks. That, or get pwned in short order.
A lot of organizations we sitting on internal bugs for years because they thought they were impossible to exploit, and now their red team can break them in hours.
Most businesses are stuck in a trap now. They know the software is exploitable, but they are organizationally slow in testing and rollout. They have to start moving fast with security and IT organizations that are cut to the bone, yet at the same time contain to much box checking deadweight.
I don't think AI slop code is the proximal cause for most of this. It is, however, the most common meme for blame.
My suspicion is (1) company execs are being told to expect company extinction if they don't force faster velocity and (2) we are increasingly building more and more complex systems, so neither AI nor humans can find all of the issues before they cause outages.
AI slop code has been happening since basically the end of COVID
entirely possible that now, several years later, the weaknesses of that approach are showing. combine that with aggressive LLM vuln tracking and here we are
I think this bet is optimistically assuming a far more competent world than the one we actually have. Have you seen the idiot clowns actually in power? The agency that might've been tasked with this hypothetical secret scrum, CISA, has been gutted and left to rot because they thought it was an enemy plot to censor them on social media or whatever. There's no secret room where the smart people are fixing things.
There is no secret room where smart people people aligned with the interests of the people of the United States are fixing things. There may not be any smart people left in the Federal government who aren't actively engaged in looting it.
I don't need your approval. Let's base them on merit, rather than comparing them to an arbitrary idea of me you have in your head, which appears to be in low standing.
Can you state one project you think they did really well and we can discuss the specifics of that? As I am genuinely confused at what you're gesturing to in such high regard.
It doesn't help that I also credit them with the death of IRS single-file online. Which itself is a travesty.
(and I don't want to dox myself, but I am content to know that my teams and I, _have_ built things I consider better.)
I know for a fact that this is not a good example. Well intentioned (surprisingly, given NDS’s inception), but not influential in the way that you think.
We've already seen an attack on transfusion blood storage.
I wouldn't minimize the impact of the ones on supermaket freezers either. It was technically dumb and somewhat laughable, but we're talking food. The affected chains had stores in very rural areas with elder people living in remote places, these supermakets would be the only purveyor of long conservation food.
I'd argue we're already there, albeit at small scale yet.
Just because vegetables are sitting out there in the open doesn't mean it shouldn't be stored in cool places before it reaches the supermarket. And last time I checked people valued eating safe meat and being treated with pristine medicine.
Preportioned meals that are hot and ready at the push of a button is a godsend for people with disabilities and/or entering older age. Someone buying a few dozen of those can be set for weeks, longer if they also continue cooking simple dishes from time to time when they feel good. This helps tremendously to keep them independent and self sufficient.
Someone coming once every month to the supermaket to restock, only to be told there's only fresh and canned food available must feel devastated IMHO.
Those people can eat raw veggies other raw ingredients until the store fridges are re-stocked. And there are also plenty of just-add-water ready meals that don't need any refrigeration. No ones survival depends on frozen food.
Not all things that are done are actually needed. Eggs survive for weeks without refrigeration too if you don't destroy their natural protective layer for example.
That's what they want you to expect. Either way, the worst possible people on our side will take advantage of it, and possibly cause it for that opportunity.
my power is still on, my water works, the street lights otw to work functioned, wifi and cell are working fine, and all of the places I stopped at over the last week for food or groceries are fine.
avaition is having some problems, but the head of the FAA gave sweetheart contracts to their son's company, and Project 2025 is all about eliminating them and privatizing everything. how much of this is just incompetence and corruption?
No single exploit should be able to take down critical infrastructure. If it does the setup is broken. Security is layers around it and the layers shouldn't trust each other nor should they be fully depended on them.
* HotSpot VM: any OpenJDK build, Oracle JDK, or GraalVM JDK. Only HotSpot generates the stub. OpenJ9 and GCJ are OK. Azul Prime (Zing), which replaces C2 with its own JIT, and any VM name not recognized as HotSpot are [?], never [!].
* x86-64 JVM on an x86-64 host.
* Version 17.0.6 or later, not at or above a version listed in FIXED_IN, and no newer than the newest releases checked (see below). Newer versions are [?]: they may carry the fix.
* The JVM reports avx512_vbmi and avx512bw, and UseAVX >= 3.
* Base64 intrinsics are on and C2/JVMCI can compile. These turn it off: -XX:-UseBASE64Intrinsics, -XX:DisableIntrinsic=_base64_decodeBlock, -Xint, -XX:TieredStopAtLevel below 4.
Wouldn't it be prudent for someone to patch even if they aren't running their code on an AVX512 system right this moment? They could be running on one.. next moment.
Depends on the company and deployment method. As Ops person, I generally don't think much about rolling out different Kubernetes Nodes and what SKU I select. So yes, you could be running on one node type today and tomorrow I upgrade the nodes under you.
We’re using a second-tier cloud provider’s managed Kubernetes offering, and in investigating our level of exposure to this, I just learned that there is variance within a node pool on whether AVX-512 is available.
This - I remember taking a suggestion to cat cpuinfo as part of container start in AWS and you do get a bit of variety as you'd expect (five year old processors last time I checked as well).
> Or, do running machines often have their CPU changed from under them without much notice?
I dunno about other cloud providers, but I know AWS can move your EC2 VM from one system to another transparently. There is a server ID you can get from the metadata, but unless you're checking it frequently, you can be moved without ever being aware.
Question is if they expose it to the guest. Many (most?) cloud platforms will make the guest see the lowest common denominator, specifically to avoid angry customers when their working setup suddenly breaks.
In the case of transparent migration, I think it's basically a must. No JIT (or even libc probably) is going to support CPU features changing at runtime.
AWS migrates live instances to new CPUs without needing to stop or reboot the guest.
When a migration is needed, the hypervisor begins copying blocks of memory to the new system, keeping track of what blocks are written inside the guest during the migration. Once enough has been copied, it hibernates the guest, copies the remaining memory, then wakes it in the new system. On a system that isn't writing to large swaths of memory, it can take only a few milliseconds. To the guest, it might appear that the CPU froze for a tiny bit of time, which could easily just look like a neighbor got noisy.
Yes, but that's irrelevant here because the CPUID report won't change across live migrations.
Consider what would happen if you were live migrated from a machine with AVX512 to one without. Your app would suddenly start crashing with SIGILL for no apparent reason. So, live migrations always preserve the apparent CPU feature set. If you started on a machine without AVX512 then until the VM is rebooted you will remain on such a (virtual) machine.
This looks like Claudese - may be kind to write such things yourself if you intend for humans to read them. (For example, “ HotSpot VM: any OpenJDK build, Oracle JDK, or GraalVM JDK. Only HotSpot generates the stub. OpenJ9 and GCJ are OK. Azul Prime (Zing), which replaces C2 with its own JIT, and any VM name not recognized as HotSpot are [?], never [!].” — I tried parsing at least five times before realizing you’re asking me to decipher LLM talk)
Azul Core definitely is - it uses upstream HotSpot.
Azul Platform Prime (formerly Zing) may or may not be depending on whether they touched the base64 intrinsic. Since it is closed-source there is no way to verify via code, which is how our research team investigates ecosystem events like this.
What's with this weird tendency to think everything you don't immediately understand is LLM? It's okay to not understand things. Have you worked with Java at all? Why do you expect to make sense of those technologies if not?
I've done Android development and there's nothing wrong with the way it's phrased. All of that is high signal information.
It’s a phenomenon that is becoming more often recognized. The words string together but they’re constructed in a way that makes it either highly burdensome to parse or inconsistent. Characterized by Unrelated thoughts strung together; the unwritten limits of parenthetical count exceeded; non-specific referent pronouns; other subtle pitfalls. This is not a fault of the human reader.
The write-up itself matches your version assumption, however it also says:
> According to Oracle, the following Oracle Java SE versions are vulnerable: 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3. We thank Oracle for providing this information ahead of publication time.
So according to Oracle at least, JRE8 versions are affected as well.
It's a bit of a mess. The first four are for the jvm, shared across all implementations: $FEATURE.$INTERIM.$UPDATE.$PATCH
$FEATURE: increased every six months when new features are released (or removed)
$INTERIM: currently always 0, reserved for future use
$UPDATE: non-feature releases like bug, security or regression fixes. Releases one month after the feature version; then every three months
$PATCH: important updates out of schedule
Specific implementations may introduce a fifth component for updates that do not come from the shared implementation but are distribution-specific (think Oracle fixing a bug that only happens in Oracle distributions)
(Then there's more, like +2 build numbers, and older versions have a slightly different format)
Oracle owns Java and Oracle is "OpenAI funded" in the sense that Oracle's data center buildouts are being done using OpenAI as a consumer.
The circular financing continues!
But seriously, the funding here doesn't matter any more than Project Zero's funding comes from Google. Big companies are trying to improve security for the common software substrates of our industries / governments.
one note: it means -XX:-UseBASE64Intrinsics OR XX:DisableIntrinsic=_base64_decodeBlock OR -Xint OR -XX:TieredStopAtLevel below 4 (-XX:TieredStopAtLevel=3 and so on)
Looks unrelated, this is being disclosed now but it was discovered a couple of weeks ago and is just now being made public at the same time.
Also I haven't looked into it, but I'm willing to be it's some free after-use memory corruption thing that has a CVSS Attack Complexity of high, the 'RCE' is speculative, and private companies push social media headlines to fit the AI cybersecurity narrative.
Not saying the doom isn't right, but sometimes it's more like a Wednesday than doomsday. Just patch it and move on. Thanks to all involved though in disclosing and patching though.
The fact that mainstream modules have such trivial bugs in logic that can be fully covered by testing is staggering. It is about time software developers will have proper test coverage for their code, at least for basic "unit" modules. Maybe we can even name a testing philosophy to match it.
Finding these kind of bugs would have required fuzzing and some kind of bound checking canaries. Not sure all bound checkers work on the hand-optimized assembly.
Or as it turns out an LLM! Not clear whether their agent spawned any classic tools...
Not sure this is as trivial as it seems. The bug triggers on a specific instruction set, on a precise input length, with a specific character at the end, and when on the hot path, and requires low level memory access checking to be detected.
For the finished jre yes. But one would hope these kind of checks are also run on a hand rolled decoder function. Fuzzing that one and finding logic bugs is a lot easier
Before you keep your security team up all night, it looks like proxies save the day here. Might not be a complete fix, obviously a real patch should be applied as soon as possible.
> Request streaming. Some current grooming profiles need partial request bodies to reach the application. A proxy that waits for the complete body removes their release timing. nginx buffers request bodies by default.
The biggest thing I have worked on recently had TWO proxies, but the second was due to process per CPU spiciness and a JVM wouldn't benefit in the least from that. Which still leaves Conway's Law, segregating rules and policies between two teams who manage things on their own basis. Always annoying to punch new headers through on such systems though.
The Log4j comparison is always a little frustrating, because it sets the bar somewhere in the neighborhood of "apocalyptic". If you're someone who believes our response to serious vulnerabilities is inadequate, you can see how Log4Shell gives a lot of cover to companies.
It is wild to find a generalizable (if platform-specific) memory corruption vulnerability in Java core Base64 handling; the tornado sirens should clearly be going off. But yes, it's not as bad as Log4Shell.
I saw some assembly in code at work for various hot path stuff but it was all written before the last version control move. The 64-bit stuff was just done in plain C though which was probably good enough by the time it needed to updated to build as 64-bit.
I tried to reproduce it on AWS (for a before/after comparison to prove the mitigation), but I couldn't. Either the reproducer from TFA doesn't work, or Fargate placed it on CPUs that don't support the instructions.
They aren’t wrong that we should be deleting more support and removing more features. The idea that the linux kernel by default builds support for all sorts of ancient systems nobody has ever heard of is absurd.
The kernel already dynamically loads kernel modules based on hardware it's running on so most of the junk isn't loaded. But for the stuff you can't dynamically load, it's a tradeoff between stripping the kernel down and supporting the most hardware.
Maybe distros could provide two builds, one for modern hardware only and one for maximum compatibility.
Back in the day, I used to build windows XP as stripped down as possible. Maybe something like that is possible? Distro installer determines what hardware you're running, then only includes what is absolutely necessary?
More annoying the first time you plug in that USB DAC or whatnot, but would reduce the attack surface heavily.
Who am I kidding... someone is going to comment that Dolphin Linux has supported this since 2013.
You have to compile the kernel to change the included features. You can certainly do that and some people have been running stripped back kernels for a long time but you can imagine why mainstream distros don’t make you do that.
Before recently kernel security was relatively acceptable.
Back in the mid-2000s I regularly simply built a kernel to match what I was running daily, and kept a stock generic kernel.
I started it in freebsd and later on Linux.
I'm not quite sure why I stopped the practice if I'm honest probably because generic felt good enough at some point and I forgot. Probably because my peripheral use became more chaotic.
That and most of the benefit is RAM footprint which stopped mattering.
Java has lots of it, even crc32 has a similar loop.
Few years back I had to manually inspect the crc32 loop (due to gzip warnings) when it was used on unalign arrays. It was ok.
The JIT can't afford the runtime to do these kinds of fixed function optimizations, and isn't tuned to perform them well.
Even your C standard library has assembly language implementations of things like strlen because your AOT C compiler can't optimise these functions optimally
Yes, JIT has lots of intrinsics.I had to inspect the crc32 loop (128bit vector instructions) as I expected to be faulty in some cases of unaligned data but it was fine.
I am very much aware where the assembly code for Hotspot is.
built for java 6, built in one didnt come to java 8, never noticed.
Now it has lots of other little functions, like inline AES256 encryption/decryption and different functions names (like encode lines for b64 split over lines).
If I owned an entire language platform with a JIT, it would not contain assembly in its standard library, it would simply be improved until it generated something at least that fast from high-level source code on that target CPU.
This is something I really like about LLVM. Their libc isn't spilling over with hand-written assembly. It's written in straightforward C++ under the belief that the compiler does, or will do, a good job.
> If I owned an entire language platform with a JIT, it would not contain assembly in its standard library, it would simply be improved until it generated something at least that fast from high-level source code on that target CPU.
Interestingly I remember a guy who worked on the JVM giving a talk and saying (back then at least) that they were working to move as much of the JVM to plain Java as they could.
I don’t think you’ve looked at LLVM libc’s string routines if you think it’s “written in straightforward C++ under the belief that the compiler does…a good job”. It’s basically an assembly DSL
I think I know vaguely what you mean. But LLVM still tries to contain the asm to the minimal, innermost performance-sensitive place where it needs to go, if it needs to be there at all, and they use intrinsics whenever possible instead of asm statements. Compare LLVM and GNU strlen. In LLVM, the logic of the function is mostly in readable code, and the way to select the target ISA makes sense. In GNU, it's 100% assembly and the target ISA is involved in scattered preprocessor directives.
I mean they wrap the assembly into functions and chain them together in C++ rather than trying to just put it all in one file (which I don’t necessarily disagree with) but I don’t really think it actually solves the problem here
That doesn't surprise me. Long strings of "A"s are the traditional way of finding/triggering buffer overflows as they're easy to spot in the memory dumps.
From the section on performing heap grooming over the network ("Remote Heap Feng Shui"):
> The current attack is sensitive to network conditions, like RTT and jitter. Low, stable round-trip times are preferred for a more reliable attack. In our controlled environment, we performed this attack over the internet through public IP addresses instead of just assuming perfect laboratory conditions. For the current attack path to achieve optimal stability and reliability in exploitation, Calif turned to physics and utilized money to solve the problem, rather than experimenting with TCP/IP stack configuration. In other words, Calif rented another VM in the same region as our target.
And the "Limitations" section:
> There is no universal payload. Each chain needs a decoder route, a live writer, a returned reader or another feedback path, a heap layout, and an application action. Every target needs a bespoke profile. The exploit is not a universal point-and-shoot.
Based on the complexity and constraints, short-term mass-exploitation seems unlikely. It will take some time before there are reliable exploits, and they may require running on infra close to the target.
But a long tail of unpatched java applications/services at high-value targets getting exploited, seems plausible to me.
Indeed, it can be a SKILL.md that writes the exploit. So in the end it could still be quite mass exploitable, only depends how much context is needed to write the exploit.
This is not my experience. Great for recon/fuzzing but rather bad at chaining together exploits or creatively making those connections, and you need A LOT of tokens and time to get real results with llms. These capabilities are not within reach for anyone without resources and skills.
But please prove me wrong, if its so easy with an llm theres millions of dollars waiting to be picked up on h1!
Calif gets unlimited tokens from OpenAI to make these findings. Theyre basically the METER operation for OpenAI and scary AI cyber narratives.
Well... depending on the application, there might still be code paths in which an attacker can supply b64 to be decoded in a way that can lead to exploitation.
Three years ago, I'd have said, yeah fix the bug but it's so complex to exploit it doesn't need immediate urgency. But now, with AI on the scene? Probably any Java application that somehow accepts user generated input can be exploited for less than a grand in AI token spend.
Yes, I guess the TL;DR is the chances of a drive by attack are low, but a sufficiently motivated actor with a specific target in mind might be able to exploit it.
Can't see it exploitable. You're writing some bytes after the allocated object memory. Java objects live in heap. The order will be completely undefined and GC moves objects around. So the best case you just write some bytes into next object, corrupting it in some way. There are millions of objects in any Java program and the program behaviour will be completely non-predicatable if you corrupt the objects. Most likely JVM will eventually crash if you corrupt object header.
>It will take some time before there are reliable exploits, and they may require running on infra close to the target.
Think that you're targeting KeyCloak and have a semi-working exploit that dumps some parts of heap memory with live tokens. You can go after 100s of banks globally, whole Tesco infra, dozens of gov.uk websites including HMRC and Home Office, azure containers... you know, anyone mature not do write their own auth server: https://www.shodan.io/search?query=keycloak
Just want to nitpick that keycloak is an extremely well auth solution for small to medium sized business as well (at least internally, especially if people spawn a new vibe coded app every other minute).
Also if you are the default Windows shop that uses the common domain controller infra. And no, Entra is not an alternative if you want any client credential flows because then the largest risk becomes your internet connection.
keycloak, jira, confluence, kafka -- lots of potential for fuckery.
a bunch of big attacks got in through secondary paths like that, e.g. the Jag-Land-Rover hacks in the UK started in jira with stolen creds and expanded laterally though PM, tracking, and documentation tools.
It's relentless, that's the thing. No human has the persistence to exploit this but you tell Claude Code to do it and come back 3 days and $100000 later and it's done.
Actually this is very analogous to php2shell. That was also extremely difficult to exploit, yet AI got access to a live website within 2 hours and stole their bitcoin.
Encode binary data in text because some dumb thing can't process binary. Text back to binary slow, so better make use of ridiculously wide vector width thing to speed up dumb decoding step we should have never become reliant on in hot paths. Derp, memory safety bug. Derp, die because performance "optimization".
Our incredibly high tower of Jenga blocks is falling down under its own weight.
So many promotions because of optimizing cosmically unnecessary work, though.
Derp, derp, this is humans making computers.
As a person who does these kinds of optimizations, it hits in the feels.
Your decoder implementation accepts all sorts of non-Base64 strings and decodes them to whatever. Among other things, it also accepts MIME Base64 (with line breaks and whitespace) and base64url strings, but decodes them to the wrong values. This is a classic example of insufficient input validation that can lead to parser mismatch vulnerabilities or worse.
>The best hacker today is neither AI nor human. It is the centaur hacker, part human, part AI.
I think only really smart people are going to be left in Security and Software. I can barely fathom what this group is doing with AI right now (ignoring that their model probably isn't nerfed and mine would be) and I don't think any of this is trainable for the average developer. This is starting to feel like some of the scientific fields where careers start when you get a MS/PhD. Or like the average developer is on the same level of not being able to convert a Word document to PDF.
Chess is very constrained, and doesn't require all sorts of knowledge about the broader context outside the game.
Once models are more hooked up to sources of information, their capabilities will improve. Currently, humans are a bottleneck for providing the information relative to specific problems.
"Take the human out of the loop" - I think there was a documentary about that, with Matthew Broderick.
> Chess is very constrained, and doesn't require all sorts of knowledge about the broader context outside the game.
e.g. chinese honeypots, or people sifting through your email, or stoned admins pushing scripts they shouldn't, etc. LLMs can sometimes account for this, but mostly via interface constraints or sanity checking later
> I think only really smart people are going to be left in Security and Software.
I'm looking forward to eventually getting there. At the moment, there's so much low hanging fruit that even someone without a clue like me can just point a fuzzer at some random Linux kernel code and still discover problems.
(Most of the problems I found from that exercise are patched by now, if you use a recent enough kernel.)
I used Kimi to drive the fuzzer. The model didn't have to do anything smart, just do the tedious work of writing the glue code to make the fuzzing work. AFL++ did the 'smart' parts, and I had the idea to kick it off and oversaw the patches.
Truth be told; as far as I can tell, the output the human gets from the AI can vary vastly in quality, depending on guardrails on the AI side. Guardrails that are internal (and opaque) to the user, combined with directives the user sets up, often manually.
(for example, I have mine keep ready reference to all of our CMMC controls and best practices)- and not only will my sessions cite referenced material as it responds, but it will do so when it writes code, as well - and it does a pretty decent job of keeping me honest. The one bit I'm struggling with is limiting complexity when it designs a solution to a problem. For larger projects, this can snowball quickly - and I haven't found an effective way to prevent this yet.
Skills can be shared, but it's a bit of a steep climb to getting an entire organization to pick the same skill (to get consistent behavior across the whole org)- sometimes an individual skill as it's written, will conflict with some other personal standard or quirk of how they work, so it's difficult to share them. This really seems, to me, to be very similar to how the software world used to work (as far as interoperability goes), earlier in history when there weren't many open standards, (and NO open source code) - and every competing OS vendor was trying to destroy their competitors so they could become a monopoly.
But yes, there's quite a bit of effort now that goes into maintaining this personal harness, and I'm sure the even smarter folks will come along and figure out workable ways of standardizing and sharing those kinds of harnesses.
I've been in this industry for 30 years, and the way I work has always changed with the times and new tools. It changed a LOT when Dev Ops became a thing. IaC, and containers. This feels kind of like that change, but maybe an order of magnitude. Almost feels like going from assembler to learning something like python; in terms of how much abstraction is being added.
When PHP2shell was announced, before the patches were available, I wrote a proxy to sanitize input. You should have an input-sanitizing proxy in front of your app servers anyway instead of waiting for patches for as-yet-undiscovered CVEs.
PHP < 8 doesn't have patches coming. It's either the proxy or be pwned. Some our honeypot machines running PHP 5 got infiltrated with full chained kernel-level exploits. The ones with the proxy didn't. Which one do you want to be?
Having said that, my proxy approach wouldn't fully protect ALL Java apps in this case, because:
A Java program that opens a TLS connection to a malicious server can be compromised, even if it exposes no service of its own.
The problem is that you can't intercept and "heal" TLS connections with a proxy, unless you also spoof the TLS certificates. However, since most Java apps don't pin certs, a workaround is using /etc/hosts and a CA cert added in cacerts. Then the proxy approach works even on outbound traffic. And you don't have to wait for the patches.
1. Add maliciousserver.com -> 127.0.0.1 (or proxy IP) in /etc/hosts
2. Java app resolves the hostname, connects to your proxy on 443
3. Proxy presents a cert for maliciousserver.com signed by your local CA
4. JVM checks: right hostname, trusted CA? handshake succeeds
5. Proxy connects to the real server (using its own resolver that bypasses /etc/hosts, or the real IP directly)
6. Normalizes Base64 in the response (assuming Calif relies on a wacky base64)
7. Relays to Java client (safe)
so what you'd do is:
1. Generate proxy CA cert
2. Install in JVM truststore (keytool)
3. /etc/hosts entries for known hostnames
4. forward_proxy config block (port, ca_cert, ca_key)
5. You have three options for routing:
HTTPS_PROXY env,
JVM flags (-Dhttps.proxyHost),
or iptables REDIRECT (covers code that ignores proxy vars)
6. Start qbixproxy
7. Verify with curl
The usual disclaimers... lock down the executable, removing any ability to read or write files, only pass traffic through like a proxy. Investigate the repo yourself, with your own Claude or ChatGPT etc. The repo even has links to pre-fill the prompts to do just that.
I'm putting this out under MIT license to help people, but under this license it disclaims all warranties, including implied warranty for merchantibility etc.
From what I understood it is generated by the JIT compiler and they don't fuzz JIT compiler output.
I am fairly sure it should still be possible to fuzz this by fuzzing the jit compiler. I understand it is not as easy as just fuzzing a regular function though.
It is even easier than fuzzing the JIT compiler in this case imo since it just inserts a fixed block of code which can be fuzzed seperately.
(Re-reading my comment, sounds like I'm throwing shade. I was just trying to state a fact. In fact most of the third party distros have been caught off guard).
It was fixed in Azul and Corretto this morning. Eclipse is notorious for slow rolling patches. It’s sad that they convinced a large number of people to run Temurin.
That Vibe Uncoding section didn't go where I thought it was going. Instead of suggesting people stop vibe coding and potentially introducing more/new vulns, they suggest vibing the removal of features and hoping the model or the tests it generated or whatever catch the edge cases. It really does feel like we're circling the drain here, folks.
The tag line "Write once, RCE everywhere" is also annoying. I get the reference, but the article explicitly says there is no generic exploit and that it probably isn't possible to make one. That's pretty much the opposite message from the tag line.
I read that mismatch as a deliberate choice to allegorize how much of a mismatch it is to see that kind of memory access issue with Java, of all things.
I see no security advisory from Elasticsearch yet,we operate multiple ES clusters and I am not exactly sure what the mitigation is here. Changing our JVM options and restarting the nodes?
Yeah I'm a bit annoyed at them for not sharing any information with us (we use the managed version).
After checking, we discovered that they are using version 26, which is a non-lte version that hasn't received patches since March 2026, and also that our cluster runs on ARM64, which is not affected by the vulnerability.
Automatic loop vectorization is unreliable since even small innocent-looking code changes can thwart loop shape detection and introduce optimization barriers. Apart from that the JIT is under a tight runtime budget, unlike an AOT compiler.
The Vector API was introduced to communicate intent more clearly to the JVM and to make optimizations more reliable. Unfortunately it is currently still incubating to make adapting it to Project Valhalla possible.
This looks like it requires G1? ZGC, ParallelGC or Serial are not affected? Smaller workloads running on singe CPU containers would default to Serial GC.
Vibe uncoding should be the way forward to prevent these bugs. LLMs should strip and bake our apps with only those required features and libraries to reduce the blast radius instead of affecting everyone. LLMs are not only good with vibe coding but also aka. vibe uncoding.
Uuuu, bug and exploits part is pretty standard so becomes boring wall of text that is instantly obsolete after patches, I hope ;) And no animation ?? How hard it is to splash there some animation ?? ;)
But there is part of article that somehow nobody mentions ! "A call for vibe-uncoding" and that is a future and sane sanity. How many unused Linux modules laying on disk ? And more commercial systems are usually worse - installer just unpacks and declares warranty void if something is modified or removed - law enforced stupidity.
You have [open] code ? You can clean it by doing very coarse work of not calling unused code or hardcoding return error on calling unused parts.
Like FTP code. Open source IT declared it dead years ago but camera and game manufacturers and probably more industries didn't get a memo. Still we do not implemented ftp replacement and ssh is single point of failure.
Leaving aside the vulnerability, this is a terrible blog post. Even the title is wrong (RCE anywhere, no only on x86). The smug tone and the LLMese makes me want nothing to do with this mob.
The risk owners, security teams, compliance teams - are all holding tight inside a tent built for the usual weather, but facing an un-announced storm now.
Their first priority is not stabilizing the tech tent. They are busy planning the risk distribution, risk outsourcing, legal prep, customer messaging, ToS/SLA reviews, contracts etc. They are reinforcing the good-old fort walls around the tech tent.
Yeah, it's a term from automation theory. I don't know how old it is, but Kasparov was talking about centaur chess (humans paired with AIs) back in 2017[1].
It got a lot more popular recently when Cory Doctorow started talking about "reverse centaurs", where the job of the human is to assist the AI.
> It took our own Quang Luong an hour to discover the vulnerability, and two more hours to develop the first working exploit. The total token cost was less than $200.
Their video of the exploit in action would be stronger if it was a bit more straightforward.
All the (impressive!) distracting graphics, the speed of change, and the lack of commentary meant it took me a few watches to actually notice the ‘seashell’ segments were wrapping remote shells that the exploit had given them.
Perhaps its time to eclipse JIT + heap based complex memory allocation algorithm runtimes like java? Now that AI can port code to other safer/better systems like rust. The "simpler" the memory management system is the easier it is to harden against such attacks.
This attack is pretty insane to me for a couple of reasons. That intrinsic implementation is compiler/runtime dependent. There are many implementations of JVMs out there that could be vulnerable.
The other scary thing is that there are likely other intrinsic implementations which hide vulnerabilities that are hard to know without further research.
This has nothing to do with having a managed runtime. It is a built-in library with hand-written assembly in a performance-critical section and therefore this could have happened to any other language with battery included as well. And indeed we should closely scrutinize other instances of hand-written assembly code. However, this specific bug us restricted to OpenJDK-derived JVMs that run on AVX512-capable CPUs.
> The Eclipse Foundation is not in the Vulnerability Group (despite their request to join), so we do not get weeks of advance notice regarding CVEs and patches (which would essentially allow us to build & test in advance of an embargo being lifted, and deliver on hour zero).
plmpsu | 22 hours ago
vips7L | 21 hours ago
https://github.com/corretto/corretto-25/blob/25.0.5.1.2/CHAN...
yabones | 21 hours ago
But the facts aren't really out yet, we'll learn more in coming hours and days...
explain | 21 hours ago
`grep -ow avx512vbmi /proc/cpuinfo | sort -u`
`-XX:-UseBASE64Intrinsics -XX:UseAVX=2`
fweimer | 20 hours ago
There are only a bunch of commits that came in the latest merge of security fixes, and this one changed VBMI-related intrinsics code, so it's a good match for what was publicly disclosed at the time.
I had to fix toHex() not to use b.length, otherwise it wouldn't print anything due to the negative array length field. GLM had web access for this, and it was able retrieve the OpenJDK fix. I don't know if it found the reproducer in its web searches.Turning this into a reliable exploit probably still requires some expertise. It's going to depend on heap layout at the time of the overflow. Targets won't be auto-selecting themselves like they did for Log4Shell.
AgentME | 21 hours ago
elric | 21 hours ago
hinkley | 16 hours ago
There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.
mey | 20 hours ago
cpach | 20 hours ago
Edit: If I understood the article correctly, the machine needs to have all the four of these flags in order to be exploitable: avx512f, avx512bw, avx512vbmi, bmi2
_msw_ | 20 hours ago
I recommend -XX:-UseBASE64Intrinsics instead.
marginalia_nu | 20 hours ago
philipkglass | 20 hours ago
marginalia_nu | 20 hours ago
philipkglass | 20 hours ago
hinkley | 16 hours ago
articulatepang | 20 hours ago
Until, presumably, there’s fixes and you can test, update etc.
marginalia_nu | 20 hours ago
xboxnolifes | 19 hours ago
eru | 18 hours ago
marginalia_nu | 18 hours ago
articulatepang | 17 hours ago
First we must stop the bleeding. After that, yes, it's worth figuring out if they should change how things are set up.
I've been in situations like this before. Sometimes the complications and abstractions were my fault, sometimes I inherited them. Either way, as responsible owners of the overall system or business, we've gotta be able to respond fast to issues.
hinkley | 17 hours ago
If it’s Java, Node, etc the binary dependencies are platform specific and 100% if your code is not unless you try very hard.
sgammon | 14 hours ago
https://github.com/elide-dev/madura
Just a compiler, but a runner isn't impossible.
jeremyjh | 19 hours ago
vehementi | 10 hours ago
wiml | 11 hours ago
benjiweber | 21 hours ago
cyberax | 19 hours ago
I suspect it's not the only issue they're going to find there.
desolate_muffin | 13 hours ago
saagarjha | 6 hours ago
12_throw_away | 18 hours ago
https://github.com/openjdk/jdk/blob/5177a70b385c16f26ede191f...
saagarjha | 6 hours ago
leca | 21 hours ago
The upside is that it’ll force legacy institutions and organizations with sub-par security to get good at security and modernize their legacy stacks. That, or get pwned in short order.
ctoth | 20 hours ago
My bet is it already happened two months ago and there's a whole secret scrum we only vaguely know about happening right now.
adrianpike | 20 hours ago
pixl97 | 20 hours ago
Most businesses are stuck in a trap now. They know the software is exploitable, but they are organizationally slow in testing and rollout. They have to start moving fast with security and IT organizations that are cut to the bone, yet at the same time contain to much box checking deadweight.
jeremyjh | 19 hours ago
ChuckSneed | 20 hours ago
thephyber | 17 hours ago
My suspicion is (1) company execs are being told to expect company extinction if they don't force faster velocity and (2) we are increasingly building more and more complex systems, so neither AI nor humans can find all of the issues before they cause outages.
red-iron-pine | 2 hours ago
entirely possible that now, several years later, the weaknesses of that approach are showing. combine that with aggressive LLM vuln tracking and here we are
Analemma_ | 20 hours ago
scottyah | 19 hours ago
jeremyjh | 19 hours ago
newsclues | 18 hours ago
scottyah | 14 hours ago
salamandars | 18 hours ago
antonvs | 17 hours ago
scottyah | 14 hours ago
nullpoint420 | 13 hours ago
scottyah | 12 hours ago
nullpoint420 | 2 hours ago
Can you state one project you think they did really well and we can discuss the specifics of that? As I am genuinely confused at what you're gesturing to in such high regard.
It doesn't help that I also credit them with the death of IRS single-file online. Which itself is a travesty.
(and I don't want to dox myself, but I am content to know that my teams and I, _have_ built things I consider better.)
zbentley | 2 hours ago
makeitdouble | 18 hours ago
I wouldn't minimize the impact of the ones on supermaket freezers either. It was technically dumb and somewhat laughable, but we're talking food. The affected chains had stores in very rural areas with elder people living in remote places, these supermakets would be the only purveyor of long conservation food.
I'd argue we're already there, albeit at small scale yet.
SoftTalker | 15 hours ago
samus | 13 hours ago
makeitdouble | 13 hours ago
Someone coming once every month to the supermaket to restock, only to be told there's only fresh and canned food available must feel devastated IMHO.
account42 | 6 hours ago
hobo123 | 12 hours ago
numpad0 | 9 hours ago
account42 | 6 hours ago
testtestmetest | 18 hours ago
specked-citrus | 13 hours ago
testtestmetest | 12 hours ago
loloquwowndueo | 17 hours ago
tclancy | 15 hours ago
loloquwowndueo | 3 hours ago
thephyber | 17 hours ago
That happened when Colonial Pipeline was hacked in 2017. It shut down a large percentage of gas station gas purchases on the US East Coast.
There were lots of severe vulns since then: shellshock, log4j, the PHP vuln from a few weeks ago.
flockonus | 17 hours ago
ps: wouldn't even be surprised if some of the banks hacks were related to this (branch) of exploit, given how much banks seem to rely on dated Java
SoftTalker | 15 hours ago
That's what finally got Microsoft to get their act together with Windows.
tomkarho | 11 hours ago
1. May you live in interesting times
2. May you find what you're looking for
rustyhancock | 10 hours ago
https://en.wikipedia.org/wiki/This_too_shall_pass
ShadowOfThePit | 5 hours ago
red-iron-pine | 3 hours ago
"i hope you live forever"
sph | 11 hours ago
red-iron-pine | 2 hours ago
my power is still on, my water works, the street lights otw to work functioned, wifi and cell are working fine, and all of the places I stopped at over the last week for food or groceries are fine.
avaition is having some problems, but the head of the FAA gave sweetheart contracts to their son's company, and Project 2025 is all about eliminating them and privatizing everything. how much of this is just incompetence and corruption?
nedt | 5 hours ago
ievans | 21 hours ago
The exploit conditions are very specific but there are still going to be a lot of hosts impacted. We at Semgrep published some free detection scripts here: https://github.com/semgrep/detection-scripts/tree/main/CVE-2...
They look for these five conditions:
cjbprime | 20 hours ago
Banditoz | 20 hours ago
Or, do running machines often have their CPU changed from under them without much notice?
stackskipton | 19 hours ago
xmodem | 19 hours ago
jamesfinlayson | 14 hours ago
Sohcahtoa82 | 19 hours ago
I dunno about other cloud providers, but I know AWS can move your EC2 VM from one system to another transparently. There is a server ID you can get from the metadata, but unless you're checking it frequently, you can be moved without ever being aware.
PhilipRoman | 18 hours ago
In the case of transparent migration, I think it's basically a must. No JIT (or even libc probably) is going to support CPU features changing at runtime.
johnbellone | 17 hours ago
acdha | 15 hours ago
Sohcahtoa82 | 11 hours ago
AWS migrates live instances to new CPUs without needing to stop or reboot the guest.
When a migration is needed, the hypervisor begins copying blocks of memory to the new system, keeping track of what blocks are written inside the guest during the migration. Once enough has been copied, it hibernates the guest, copies the remaining memory, then wakes it in the new system. On a system that isn't writing to large swaths of memory, it can take only a few milliseconds. To the guest, it might appear that the CPU froze for a tiny bit of time, which could easily just look like a neighbor got noisy.
mike_hearn | 10 hours ago
Consider what would happen if you were live migrated from a machine with AVX512 to one without. Your app would suddenly start crashing with SIGILL for no apparent reason. So, live migrations always preserve the apparent CPU feature set. If you started on a machine without AVX512 then until the VM is rebooted you will remain on such a (virtual) machine.
tecleandor | 7 hours ago
bonsai_spool | 20 hours ago
Yokolos | 20 hours ago
kaboberg | 19 hours ago
Azul Platform Prime (formerly Zing) may or may not be depending on whether they touched the base64 intrinsic. Since it is closed-source there is no way to verify via code, which is how our research team investigates ecosystem events like this.
pjmlp | 10 hours ago
Here are three more, PTC, Aicas, and ART (even if it runs DEX instead, and only the core language is supported).
stevenhuang | 8 hours ago
I've done Android development and there's nothing wrong with the way it's phrased. All of that is high signal information.
bonsai_spool | 7 hours ago
Thanks for the middlebrow dismissal
PantaloonFlames | 3 hours ago
icedchai | 2 hours ago
bikezen | 20 hours ago
> According to Oracle, the following Oracle Java SE versions are vulnerable: 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3. We thank Oracle for providing this information ahead of publication time.
So according to Oracle at least, JRE8 versions are affected as well.
xur17 | 20 hours ago
[0] https://www.oracle.com/java/technologies/javase/jdk25-archiv...
rhdunn | 19 hours ago
[1] https://www.oracle.com/java/technologies/downloads/#java25
K0IN | 18 hours ago
nullpoint420 | 14 hours ago
looperhacks | 13 hours ago
$FEATURE: increased every six months when new features are released (or removed) $INTERIM: currently always 0, reserved for future use $UPDATE: non-feature releases like bug, security or regression fixes. Releases one month after the feature version; then every three months $PATCH: important updates out of schedule
Specific implementations may introduce a fifth component for updates that do not come from the shared implementation but are distribution-specific (think Oracle fixing a bug that only happens in Oracle distributions)
(Then there's more, like +2 build numbers, and older versions have a slightly different format)
testtestmetest | 18 hours ago
thephyber | 17 hours ago
The circular financing continues!
But seriously, the funding here doesn't matter any more than Project Zero's funding comes from Google. Big companies are trying to improve security for the common software substrates of our industries / governments.
red-iron-pine | 3 hours ago
"improve security" in the same way that my dad used to beat us
apolo64 | 3 hours ago
milkshakes | 17 hours ago
sgammon | 14 hours ago
zbentley | 2 hours ago
yburkov | 5 hours ago
ktm5j | 3 hours ago
mzs | 21 hours ago
-XX:-UseBASE64Intrinsics to disable hardware-accelerated Base64 encoding and decoding, or
-XX:UseAVX=2 to disable AVX-512. Apply this flag only on x86-64 hosts. OpenJDK on ARM doesn't recognize it and will fail to start.
marginalia_nu | 21 hours ago
binsquare | 15 hours ago
I know I purposely do it for smolvm to avoid exposure
doctorpangloss | 21 hours ago
TZubiri | 21 hours ago
Also I haven't looked into it, but I'm willing to be it's some free after-use memory corruption thing that has a CVSS Attack Complexity of high, the 'RCE' is speculative, and private companies push social media headlines to fit the AI cybersecurity narrative.
Not saying the doom isn't right, but sometimes it's more like a Wednesday than doomsday. Just patch it and move on. Thanks to all involved though in disclosing and patching though.
Sigmazero60 | 21 hours ago
eyalitki | 21 hours ago
ajasmin | 20 hours ago
Or as it turns out an LLM! Not clear whether their agent spawned any classic tools...
stassats | 15 hours ago
I used memory protection for that. mmap a page, align the string start/end to the page boundaries. Catches both bad reads and writes.
Noe2097 | 20 hours ago
spockz | 20 hours ago
nacnud | 21 hours ago
It's a heap out-of-bounds write in Java’s AVX-512 Base64 decoder.
kaliszad | 21 hours ago
yabones | 21 hours ago
> Request streaming. Some current grooming profiles need partial request bodies to reach the application. A proxy that waits for the complete body removes their release timing. nginx buffers request bodies by default.
https://calif.io/java4shell/#limitations
hinkley | 16 hours ago
hypfer | 20 hours ago
Genuine question. Everything I see is Intel all the time. I know that people at home switched to AMD, but they don't run enterprise java.
I also have been told that apparently EPYC was hyped for a while and some hosters give you that. But do corporations run the java applications there?
The name makes it sound like Log4J or the PHP thing, but from what I can tell right now, it kinda isn't all that relevant?
p_l | 20 hours ago
CodesInChaos | 20 hours ago
t0mas88 | 19 hours ago
jamesfinlayson | 12 hours ago
I never did it for any ECS stuff as that was more work to get working from top to bottom.
tptacek | 20 hours ago
It is wild to find a generalizable (if platform-specific) memory corruption vulnerability in Java core Base64 handling; the tornado sirens should clearly be going off. But yes, it's not as bad as Log4Shell.
aleksejs | 19 hours ago
llama052 | 17 hours ago
lbourdages | 14 hours ago
nikanj | 20 hours ago
Why do we even pay for Ubuntu?
cpach | 20 hours ago
https://www.debian.org/security/
mitchweaver | 20 hours ago
Fortunately I run name-brand Oracle(R) Java(tm), which did publish updated packages.
mnw21cam | 4 hours ago
cpach | 20 hours ago
ryanschaefer | 20 hours ago
cpach | 19 hours ago
dboreham | 20 hours ago
secondcoming | 20 hours ago
magackame | 20 hours ago
jamesfinlayson | 12 hours ago
I saw some assembly in code at work for various hot path stuff but it was all written before the last version control move. The 64-bit stuff was just done in plain C though which was probably good enough by the time it needed to updated to build as 64-bit.
saagarjha | 6 hours ago
iririririr | 20 hours ago
cedricbonhomme | 20 hours ago
rbanffy | 20 hours ago
formerly_proven | 20 hours ago
rbanffy | 20 hours ago
looperhacks | 4 hours ago
mushufasa | 20 hours ago
3dedb728-3f77 | 20 hours ago
cpach | 19 hours ago
drum55 | 20 hours ago
eru | 18 hours ago
Gigachad | 18 hours ago
Maybe distros could provide two builds, one for modern hardware only and one for maximum compatibility.
cheeze | 13 hours ago
More annoying the first time you plug in that USB DAC or whatnot, but would reduce the attack surface heavily.
Who am I kidding... someone is going to comment that Dolphin Linux has supported this since 2013.
Gigachad | 13 hours ago
Before recently kernel security was relatively acceptable.
nly | 9 hours ago
rustyhancock | 7 hours ago
I started it in freebsd and later on Linux.
I'm not quite sure why I stopped the practice if I'm honest probably because generic felt good enough at some point and I forgot. Probably because my peripheral use became more chaotic.
That and most of the benefit is RAM footprint which stopped mattering.
AuthAuth | 18 hours ago
drum55 | 15 hours ago
exabrial | 16 hours ago
kenferry | 10 hours ago
See https://news.ycombinator.com/item?id=50371408
Noe2097 | 20 hours ago
xxs | 11 hours ago
String operations also contain instrinsics.
nly | 9 hours ago
Even your C standard library has assembly language implementations of things like strlen because your AOT C compiler can't optimise these functions optimally
xxs | 3 hours ago
Yes, JIT has lots of intrinsics.I had to inspect the crc32 loop (128bit vector instructions) as I expected to be faulty in some cases of unaligned data but it was fine.
I am very much aware where the assembly code for Hotspot is.
spullara | 20 hours ago
DarkmSparks | 20 hours ago
now panicking in case some LLM imported this without me noticing.
edit: it did. :(
asveikau | 14 hours ago
Genuinely curious, not meant to be a snarky or aggressive question.
CrimsonRain | 10 hours ago
DarkmSparks | 10 hours ago
Now it has lots of other little functions, like inline AES256 encryption/decryption and different functions names (like encode lines for b64 split over lines).
jeffbee | 20 hours ago
This is something I really like about LLVM. Their libc isn't spilling over with hand-written assembly. It's written in straightforward C++ under the belief that the compiler does, or will do, a good job.
jamesfinlayson | 12 hours ago
Interestingly I remember a guy who worked on the JVM giving a talk and saying (back then at least) that they were working to move as much of the JVM to plain Java as they could.
nly | 9 hours ago
jeffbee | 3 hours ago
saagarjha | 6 hours ago
jeffbee | 3 hours ago
saagarjha | 2 hours ago
9029 | 20 hours ago
spidermonkey23 | 20 hours ago
rb12345 | 9 hours ago
lucasluitjes | 19 hours ago
> The current attack is sensitive to network conditions, like RTT and jitter. Low, stable round-trip times are preferred for a more reliable attack. In our controlled environment, we performed this attack over the internet through public IP addresses instead of just assuming perfect laboratory conditions. For the current attack path to achieve optimal stability and reliability in exploitation, Calif turned to physics and utilized money to solve the problem, rather than experimenting with TCP/IP stack configuration. In other words, Calif rented another VM in the same region as our target.
And the "Limitations" section:
> There is no universal payload. Each chain needs a decoder route, a live writer, a returned reader or another feedback path, a heap layout, and an application action. Every target needs a bespoke profile. The exploit is not a universal point-and-shoot.
Based on the complexity and constraints, short-term mass-exploitation seems unlikely. It will take some time before there are reliable exploits, and they may require running on infra close to the target.
But a long tail of unpatched java applications/services at high-value targets getting exploited, seems plausible to me.
jonstewart | 19 hours ago
Mass exploitation, maybe. But LLMs are pretty good at finding exploits now as Calif showed at unprompted a few weeks ago.
AdrenalinMd | 19 hours ago
testtestmetest | 16 hours ago
But please prove me wrong, if its so easy with an llm theres millions of dollars waiting to be picked up on h1!
Calif gets unlimited tokens from OpenAI to make these findings. Theyre basically the METER operation for OpenAI and scary AI cyber narratives.
red-iron-pine | 3 hours ago
and the level of token require is not out of reach of many business either
luka2233 | 19 hours ago
hinkley | 17 hours ago
mschuster91 | 10 hours ago
Three years ago, I'd have said, yeah fix the bug but it's so complex to exploit it doesn't need immediate urgency. But now, with AI on the scene? Probably any Java application that somehow accepts user generated input can be exploited for less than a grand in AI token spend.
afavour | 19 hours ago
So, patch your systems, governments!
hinkley | 17 hours ago
b800h | 7 hours ago
lowbloodsugar | 18 hours ago
Don't see how this is a safe assumption in the modern era of LLMs.
afavour | 18 hours ago
LLMs aren’t magic, they can’t alter physics.
makeitdouble | 18 hours ago
In particular booting a VM is cheap, having them in all potential regions won't break the bank.
Xirdus | 18 hours ago
loloquwowndueo | 17 hours ago
codebje | 17 hours ago
ChuckMcM | 12 hours ago
drob518 | 4 hours ago
Uptrenda | 17 hours ago
vbezhenar | 16 hours ago
asdf88990 | 15 hours ago
agilob | 11 hours ago
guipsp | 14 hours ago
kimi | 9 hours ago
worthless-trash | 11 hours ago
saagarjha | 6 hours ago
cowlevel | 5 hours ago
tclancy | 15 hours ago
tru3_power | 16 hours ago
neoecos | 14 hours ago
darkstar_16 | 9 hours ago
agilob | 11 hours ago
Think that you're targeting KeyCloak and have a semi-working exploit that dumps some parts of heap memory with live tokens. You can go after 100s of banks globally, whole Tesco infra, dozens of gov.uk websites including HMRC and Home Office, azure containers... you know, anyone mature not do write their own auth server: https://www.shodan.io/search?query=keycloak
theteapot | 10 hours ago
Anyone mature enough not to write their own auth server? I agree with the sentiment.
ptman | 7 hours ago
raxxorraxor | 7 hours ago
Also if you are the default Windows shop that uses the common domain controller infra. And no, Entra is not an alternative if you want any client credential flows because then the largest risk becomes your internet connection.
indigo945 | 6 hours ago
But then, if e-mail and other essential services are down, do you even really care? It's not like you're getting any work done anyhow.
bradleyjg | 5 hours ago
https://www.cisa.gov/sites/default/files/2025-03/CSRBReviewO...
cbm-vic-20 | 4 hours ago
snort
PantaloonFlames | 3 hours ago
red-iron-pine | 3 hours ago
a bunch of big attacks got in through secondary paths like that, e.g. the Jag-Land-Rover hacks in the UK started in jira with stolen creds and expanded laterally though PM, tracking, and documentation tools.
tus666 | 10 hours ago
Haven't you heard of this new fangled thing called AI?
Some people love living under rocks.
izacus | 9 hours ago
cowlevel | 5 hours ago
izacus | 5 hours ago
Yes, it needs patching but it's hardly php2shell.
Also last I checked these agents are controlled by people - when's the last time US put anyone to jail for cyber attacks or at least fined them?
cowlevel | 3 hours ago
titzer | 19 hours ago
Our incredibly high tower of Jenga blocks is falling down under its own weight.
So many promotions because of optimizing cosmically unnecessary work, though.
Derp, derp, this is humans making computers.
As a person who does these kinds of optimizations, it hits in the feels.
LastTrain | 19 hours ago
aaronvg | 19 hours ago
bullen | 19 hours ago
http://move.rupy.se/file/base64.txt
If this part becomes the bottleneck; so I need to write a GPU accelerated version I'll eat my own hat.
CAP_NET_ADMIN | 18 hours ago
I've easily reached a point where it was worth it to go AVX route in my "for funsies" game that I'm making.
CAP_NET_ADMIN | 18 hours ago
bullen | 18 hours ago
CAP_NET_ADMIN | 18 hours ago
bullen | 16 hours ago
layer8 | 17 hours ago
fsnovask | 19 hours ago
I think only really smart people are going to be left in Security and Software. I can barely fathom what this group is doing with AI right now (ignoring that their model probably isn't nerfed and mine would be) and I don't think any of this is trainable for the average developer. This is starting to feel like some of the scientific fields where careers start when you get a MS/PhD. Or like the average developer is on the same level of not being able to convert a Word document to PDF.
colonCapitalDee | 18 hours ago
We'll see how long the centaur era lasts though. Hopefully a very long time
eru | 18 hours ago
antonvs | 14 hours ago
Once models are more hooked up to sources of information, their capabilities will improve. Currently, humans are a bottleneck for providing the information relative to specific problems.
"Take the human out of the loop" - I think there was a documentary about that, with Matthew Broderick.
happysadpanda2 | 11 hours ago
faheel | 10 hours ago
red-iron-pine | 2 hours ago
e.g. chinese honeypots, or people sifting through your email, or stoned admins pushing scripts they shouldn't, etc. LLMs can sometimes account for this, but mostly via interface constraints or sanity checking later
eru | 18 hours ago
I'm looking forward to eventually getting there. At the moment, there's so much low hanging fruit that even someone without a clue like me can just point a fuzzer at some random Linux kernel code and still discover problems.
(Most of the problems I found from that exercise are patched by now, if you use a recent enough kernel.)
I used Kimi to drive the fuzzer. The model didn't have to do anything smart, just do the tedious work of writing the glue code to make the fuzzing work. AFL++ did the 'smart' parts, and I had the idea to kick it off and oversaw the patches.
Pokepokalypse | 14 hours ago
(for example, I have mine keep ready reference to all of our CMMC controls and best practices)- and not only will my sessions cite referenced material as it responds, but it will do so when it writes code, as well - and it does a pretty decent job of keeping me honest. The one bit I'm struggling with is limiting complexity when it designs a solution to a problem. For larger projects, this can snowball quickly - and I haven't found an effective way to prevent this yet.
Skills can be shared, but it's a bit of a steep climb to getting an entire organization to pick the same skill (to get consistent behavior across the whole org)- sometimes an individual skill as it's written, will conflict with some other personal standard or quirk of how they work, so it's difficult to share them. This really seems, to me, to be very similar to how the software world used to work (as far as interoperability goes), earlier in history when there weren't many open standards, (and NO open source code) - and every competing OS vendor was trying to destroy their competitors so they could become a monopoly.
But yes, there's quite a bit of effort now that goes into maintaining this personal harness, and I'm sure the even smarter folks will come along and figure out workable ways of standardizing and sharing those kinds of harnesses.
I've been in this industry for 30 years, and the way I work has always changed with the times and new tools. It changed a LOT when Dev Ops became a thing. IaC, and containers. This feels kind of like that change, but maybe an order of magnitude. Almost feels like going from assembler to learning something like python; in terms of how much abstraction is being added.
george_max | 18 hours ago
Could this be what triggered the recent outages?
https://x.com/InfiShark/status/2122786295105913332
bitlad | 18 hours ago
brightbed | 17 hours ago
But. Just. Why. Maybe just KISS.
saagarjha | 6 hours ago
EGreg | 17 hours ago
https://github.com/Qbix/proxy/blob/main/java4shell.md
When PHP2shell was announced, before the patches were available, I wrote a proxy to sanitize input. You should have an input-sanitizing proxy in front of your app servers anyway instead of waiting for patches for as-yet-undiscovered CVEs.
PHP < 8 doesn't have patches coming. It's either the proxy or be pwned. Some our honeypot machines running PHP 5 got infiltrated with full chained kernel-level exploits. The ones with the proxy didn't. Which one do you want to be?
https://github.com/Qbix/proxy -- now updated to help mitigate java4shell
Having said that, my proxy approach wouldn't fully protect ALL Java apps in this case, because:
A Java program that opens a TLS connection to a malicious server can be compromised, even if it exposes no service of its own.
The problem is that you can't intercept and "heal" TLS connections with a proxy, unless you also spoof the TLS certificates. However, since most Java apps don't pin certs, a workaround is using /etc/hosts and a CA cert added in cacerts. Then the proxy approach works even on outbound traffic. And you don't have to wait for the patches.
so what you'd do is: The usual disclaimers... lock down the executable, removing any ability to read or write files, only pass traffic through like a proxy. Investigate the repo yourself, with your own Claude or ChatGPT etc. The repo even has links to pre-fill the prompts to do just that.I'm putting this out under MIT license to help people, but under this license it disclaims all warranties, including implied warranty for merchantibility etc.
stephenr | 13 hours ago
Anyone on a Debian derivative can use Ondřej Surý's packages which have the patch back ported to at least 7.3: https://deb.sury.org/
Also, I'm not sure I'd really trust what looks like LLM generated overly verbose code as a security layer.
ozgrakkurt | 17 hours ago
Is it difficult to just go through Java, nodejs etc. Base64/hex/.. implementations and fuzz them all?
Does anyone know why this would be missed?
knapsack-dev | 17 hours ago
jooops1 | 16 hours ago
saagarjha | 6 hours ago
ozgrakkurt | 5 hours ago
I am fairly sure it should still be possible to fuzz this by fuzzing the jit compiler. I understand it is not as easy as just fuzzing a regular function though.
It is even easier than fuzzing the JIT compiler in this case imo since it just inserts a fixed block of code which can be fuzzed seperately.
exabrial | 16 hours ago
(Re-reading my comment, sounds like I'm throwing shade. I was just trying to state a fact. In fact most of the third party distros have been caught off guard).
3r7j6qzi9jvnve | 15 hours ago
Well, at least we don't have any java server internet-facing here...
vips7L | 15 hours ago
p2detar | 7 hours ago
asdfaoeu | 7 hours ago
robinla | 8 hours ago
Source: https://github.com/adoptium/adoptium-support/issues/1575#iss...
ethagnawl | 16 hours ago
Also, (S)FTP is dead? Since when?
Woodi | 9 hours ago
Since it's overcomplicated ?
kccqzy | 5 hours ago
I don’t know any use case of FTP in 2026. If your box is too weak to support encryption to use SFTP, people use TFTP instead.
Validark | 15 hours ago
Should say "output_len & 0xFF >= 64" instead. Bzhi only looks at the bottom byte.
Dwedit | 14 hours ago
rf15 | 10 hours ago
ulrikrasmussen | 8 hours ago
tstenner | 2 hours ago
usrusr | 2 hours ago
sabretooth1405 | 14 hours ago
thayne | 14 hours ago
CountVonGuetzli | 5 hours ago
After checking, we discovered that they are using version 26, which is a non-lte version that hasn't received patches since March 2026, and also that our cluster runs on ARM64, which is not affected by the vulnerability.
thayne | 14 hours ago
samus | 14 hours ago
The Vector API was introduced to communicate intent more clearly to the JVM and to make optimizations more reliable. Unfortunately it is currently still incubating to make adapting it to Project Valhalla possible.
tomekb | 12 hours ago
sgt | 12 hours ago
vips7L | 12 hours ago
sgt | 10 hours ago
Are you sure that's default? I am not talking about Java 27, practically nobody is running that yet
tomekb | 2 hours ago
vips7L | 12 hours ago
https://openjdk.org/jeps/523
xxs | 11 hours ago
tesnorindian | 12 hours ago
Woodi | 12 hours ago
But there is part of article that somehow nobody mentions ! "A call for vibe-uncoding" and that is a future and sane sanity. How many unused Linux modules laying on disk ? And more commercial systems are usually worse - installer just unpacks and declares warranty void if something is modified or removed - law enforced stupidity.
You have [open] code ? You can clean it by doing very coarse work of not calling unused code or hardcoding return error on calling unused parts.
Like FTP code. Open source IT declared it dead years ago but camera and game manufacturers and probably more industries didn't get a memo. Still we do not implemented ftp replacement and ssh is single point of failure.
badgersnake | 11 hours ago
zkmon | 11 hours ago
Their first priority is not stabilizing the tech tent. They are busy planning the risk distribution, risk outsourcing, legal prep, customer messaging, ToS/SLA reviews, contracts etc. They are reinforcing the good-old fort walls around the tech tent.
f646993e074382f | 11 hours ago
voidUpdate | 10 hours ago
AI is... a horse?
ad_hockey | 8 hours ago
It got a lot more popular recently when Cory Doctorow started talking about "reverse centaurs", where the job of the human is to assist the AI.
[1] https://medium.com/conversations-with-tyler/garry-kasparov-t...
theteapot | 9 hours ago
saagarjha | 6 hours ago
SoraTakai | 8 hours ago
yossufyahia | 8 hours ago
cowlevel | 5 hours ago
djha-skin | 5 hours ago
I don't know, man. I just don't know.
jrmg | 4 hours ago
All the (impressive!) distracting graphics, the speed of change, and the lack of commentary meant it took me a few watches to actually notice the ‘seashell’ segments were wrapping remote shells that the exploit had given them.
https://youtu.be/-EOYmL4UKvs
giiiiiit | 3 hours ago
ghm2199 | 2 hours ago
This attack is pretty insane to me for a couple of reasons. That intrinsic implementation is compiler/runtime dependent. There are many implementations of JVMs out there that could be vulnerable.
The other scary thing is that there are likely other intrinsic implementations which hide vulnerabilities that are hard to know without further research.
samus | an hour ago
quatrevingts | an hour ago
mooreds | 2 hours ago
Bummer that:
> The Eclipse Foundation is not in the Vulnerability Group (despite their request to join), so we do not get weeks of advance notice regarding CVEs and patches (which would essentially allow us to build & test in advance of an embargo being lifted, and deliver on hour zero).