1170 points | 4d ago | Discuss on Hacker News | Back to Radar
With log4shell, the exploit was a single shot where an attacker didn't even have to aim.
Just because you add "4shell" to the end of a brand name for a vulnerability, it doesn't make it the same.
What is the same, however, is the amount of fear and panic that come from very scary marketing landing pages. It leads to people thinking it's the same thing, and for those who lived through log4shell, a lot of stress that may not be necessary.
It's a bug that should be prioritized higher than many others, especially for internet-facing systems.
But it is common practice to describe the maximum possible negative effect of these bugs, and that may or may not manifest in a given software system. It will look rather bad in the abstract, and _potentially_ far less bad in practice in many cases.
https://github.com/corretto/corretto-25/blob/25.0.5.1.2/CHAN...
But the facts aren't really out yet, we'll learn more in coming hours and days...
`grep -ow avx512vbmi /proc/cpuinfo | sort -u`
`-XX:-UseBASE64Intrinsics -XX:UseAVX=2`
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. *** ITERATION 4076, input length 67: DESTINATION BUFFER OVERRUN DETECTED
canary.length = -1700370022 (expected 64)
canary bytes = 69 a6 9a 69 a6 9a 69 a6 9a 69 a6 9a 69 a6 9a 69 a6 9a 69 a6 9a 69 a6 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
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.
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 recommend -XX:-UseBASE64Intrinsics instead.
Until, presumably, there’s fixes and you can test, update etc.
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.
If it’s Java, Node, etc the binary dependencies are platform specific and 100% if your code is not unless you try very hard.
https://github.com/elide-dev/madura
Just a compiler, but a runner isn't impossible.
I suspect it's not the only issue they're going to find there.
https://github.com/openjdk/jdk/blob/5177a70b385c16f26ede191f...
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.
My bet is it already happened two months ago and there's a whole secret scrum we only vaguely know about happening right now.
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.
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.
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
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 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.
But most baked goods, fresh produce and fruit will be OK for a few days or weeks, some things even longer. And if they do spoil, it will be pretty obvious and not really dangerous. Dairy and especially raw meat are the things that can go toxic pretty quickly.
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.
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.
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
That's what finally got Microsoft to get their act together with Windows.
1. May you live in interesting times
2. May you find what you're looking for
1. May you live in interesting times.
2. May you be recognized by people in high places.
3. May you get what you wish for."i hope you live forever"
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?
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:
* 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.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.
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.
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.
It's just a tradeoff. Most users don't care about the latest CPU features and having a bigger pool of machines to migrate VMs to simplifies operations.
Then, in that case you wouldn't be worried about this big, as you wouldn't be using the AVX512 extensions.
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.
Here are three more, PTC, Aicas, and ART (even if it runs DEX instead, and only the core language is supported).
I've done Android development and there's nothing wrong with the way it's phrased. All of that is high signal information.
Thanks for the middlebrow dismissal
> 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.
[0] https://www.oracle.com/java/technologies/javase/jdk25-archiv...
[1] https://www.oracle.com/java/technologies/downloads/#java25
$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)
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.
"improve security" in the same way that my dad used to beat us
kmiles@dora tmp.wdOJ2BRVwa % /opt/graalvm/bin/java Base64Trigger
runtime=21.0.5+9-LTS-jvmci-23.1-b48
vm=Java HotSpot(TM) 64-Bit Server VM
rejected=true changed=0 first=-1 last=-1
NOT REPRODUCED-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.
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.
Or as it turns out an LLM! Not clear whether their agent spawned any classic tools...
I used memory protection for that. mmap a page, align the string start/end to the page boundaries. Catches both bad reads and writes.
It's a heap out-of-bounds write in Java’s AVX-512 Base64 decoder.
> 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.
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?
I never did it for any ECS stuff as that was more work to get working from top to bottom.
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.
Why do we even pay for Ubuntu?
Fortunately I run name-brand Oracle(R) Java(tm), which did publish updated packages.
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.
Maybe distros could provide two builds, one for modern hardware only and one for maximum compatibility.
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.
Before recently kernel security was relatively acceptable.
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.
But with LLMs that may not be as big a blocker as before...
String operations also contain instrinsics.
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.
now panicking in case some LLM imported this without me noticing.
edit: it did. :(
Genuinely curious, not meant to be a snarky or aggressive question.
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).
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.
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.
> 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.
Mass exploitation, maybe. But LLMs are pretty good at finding exploits now as Calif showed at unprompted a few weeks 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.
and the level of token require is not out of reach of many business either
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.
So, patch your systems, governments!
Don't see how this is a safe assumption in the modern era of LLMs.
LLMs aren’t magic, they can’t alter physics.
In particular booting a VM is cheap, having them in all potential regions won't break the bank.
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
Anyone mature enough not to write their own auth server? I agree with the sentiment.
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.
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.
https://www.cisa.gov/sites/default/files/2025-03/CSRBReviewO...
snort
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.
Haven't you heard of this new fangled thing called AI?
Some people love living under rocks.
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?
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.
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.
I've easily reached a point where it was worth it to go AVX route in my "for funsies" game that I'm making.
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.
We'll see how long the centaur era lasts though. Hopefully a very long time
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.
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'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.
(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.
Could this be what triggered the recent outages?
But. Just. Why. Maybe just KISS.
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.
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.
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.
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?
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).
Well, at least we don't have any java server internet-facing here...
Source: https://github.com/adoptium/adoptium-support/issues/1575#iss...
Also, (S)FTP is dead? Since when?
Since it's overcomplicated ?
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.
Should say "output_len & 0xFF >= 64" instead. Bzhi only looks at the bottom byte.
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.
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.
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.
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.
AI is... a horse?
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...
I don't know, man. I just don't know.
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.
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.
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).
> Intel Xeon: Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids AMD EPYC and Ryzen: Zen 4 or newer
Guess I don't have to do anything. All of my servers run on last gen hardware, on Zen 2 anyway.
Comments are loaded live from Hacker News and are not stored by Mid or Real.