BriefTechNews
Java4Shell: The 9.2-CVSS OpenJDK RCE That Bypasses WAFs

Java4Shell: The 9.2-CVSS OpenJDK RCE That Bypasses WAFs

7 min read · 12 sources

TL;DR
  • CVE-2026-114938 is a 9.2-severity pre-auth RCE in OpenJDK's AVX-512 Base64 decoding that corrupts heap memory via integer underflow.
  • AWS Network Load Balancer now supports mTLS in verify mode, offloading client certificate authentication and revocation checks at Layer 4.
  • Together AI deleted its megakernels and recovered 98% of performance using CUDA Graphs on default Inductor kernels, then beat them by up to 1.7x.
  • GitHub CLI v2.105.0 adds gh event listen, letting scripts wait for PR reviews, state changes, and check suites without polling.
  • An IEEE study of 8.8 billion test executions found 9.8% to 16.3% of failed runs involved missed flaky failures.

Today’s biggest story is a Java vulnerability with a CVSS score that should make every platform team drop what they’re doing. CVE-2026-114938, nicknamed “Java4Shell,” is a critical remote code execution bug in OpenJDK’s optimized AVX-512 Base64 decoding assembly. It’s rated 9.2 on the CVSSv4.0 scale, it’s exploitable pre-auth, and proof-of-concept exploits are already demonstrated against Jenkins, Confluence, and Tomcat. The bug is an integer underflow in hand-written assembly that leads to an out-of-bounds heap write - the kind of memory corruption that makes WAF rules useless because the payload looks like legitimate Base64.

The trigger is deceptively simple: 64 ‘A’ characters followed by an ‘=’ sign. That input causes an integer underflow in the AVX-512 decoding path, which then writes out of bounds on the heap. Remote unauthenticated attackers can corrupt memory and achieve code execution. The affected versions are OpenJDK 17.0.6 and later on x86-64 hardware. If you’re running any Java service on modern Intel or AMD chips, you need to patch now. Don’t assume your WAF will save you - the Wiz analysis explicitly notes that WAF rules may not cover all exploitation paths. If you can’t patch immediately, disabling Base64 intrinsics is the stopgap.

Together AI’s compiler hit over 1100 TPS for Llama 1B on H100, beating its old hand-written megakernels by up to 1.7x.

AWS NLB Finally Speaks mTLS

Source: aws.amazon.com ↗

AWS announced mutual TLS support for Network Load Balancer, and it’s a bigger deal than the announcement suggests. NLB operates at Layer 4 and handles millions of requests per second, but until now, anyone needing client certificate authentication had to build a home-grown mTLS solution or sit behind a third-party proxy. That meant running extra infrastructure just to terminate TLS at a layer where you shouldn’t need application logic.

The new “verify mode” lets NLB authenticate client X.509 certificates, check revocation, and filter clients by certificate identity directly at the load balancer. You configure a trust store, set revocation checks, and define certificate identity filters - then the backend services never see a request from an unauthenticated client. This simplifies PKI integration and removes a whole class of home-grown proxy infrastructure. For teams running zero-trust architectures where every client must present a valid certificate, this eliminates a significant operational burden.

The Flaky-Test Tooling Reality Check

Source: harness.io ↗

Harness published a comparison of seven flaky-test tools that cuts through the marketing. Their argument: vendors differ more in quarantine, recovery, and adoption cost than in detection. The detection algorithms are largely commoditized at this point - what matters is what happens after a flaky test is identified. Can the tool quarantine it so it doesn’t block merges? Can it automatically retry and recover? How much does it cost to adopt and maintain?

The numbers backing this up are stark. An IEEE study of 8.8 billion test executions found that 9.8% to 16.3% of failed runs involved missed flaky failures. That’s a huge chunk of CI time wasted on tests that are failing for the wrong reasons. If your CI pipeline is spending 10-16% of its failure budget on tests that aren’t actually testing anything, that’s not a tooling problem - that’s a trust problem. Engineers start ignoring red builds, and real regressions slip through.

AI Is a Third-Party Dependency Until It Isn't

Source: incident.io ↗

incident.io’s argument that AI models should be treated like any other third-party dependency is correct, with one caveat: defining “normal” is harder for AI. Engineers from Skyscanner and incident.io agree the analogy mostly holds, but model APIs are nondeterministic in ways that traditional dependencies aren’t. You can’t just check a version number and know what behavior you’re getting.

The practical takeaway is that any dependency without a proven history of meeting your target needs an alternative. That means dedicated platform ownership, an LLM gateway, and real observability on model calls. A model provider is another link in the dependency chain that caps theoretical availability - if your model provider has 99.9% uptime but your target is 99.99%, you need a failover plan. Treating AI like a black box that magically works is how you discover your SLO breach at 3 AM.

OpenVINO: Inference Optimization Without the Framework Lock-in

Source: github.com ↗

OpenVINO is Intel’s open-source toolkit for optimizing and deploying deep learning models across CPU (x86, ARM), GPU (Intel integrated and discrete), and Intel NPU accelerators. It supports models from PyTorch, TensorFlow, ONNX, Keras, PaddlePaddle, and JAX/Flax, and installs with a simple pip install -U openvino. The repo provides code examples for converting and running models from the major frameworks.

For engineers running inference in production, the appeal is resource reduction. You can take a model trained in PyTorch, convert it to OpenVINO’s Intermediate Representation, and often get significant performance improvements without rewriting your training code. It’s particularly useful for edge-to-cloud deployments where you need the same model running on diverse hardware. The trade-off is that you’re adding a conversion step and a new runtime dependency, so it’s worth benchmarking before committing.

OpenSRE: A CLI Agent That Fixes Your CI

Source: github.com ↗

OpenSRE is an open-source CLI agent that investigates failed CI/CD runs, traces the cause, and pushes a fix for review. It’s self-hosted and can run with your own models, which matters if you’re in a regulated industry or just don’t want your code leaving your infrastructure. The tool distinguishes between CI-caused failures and code-caused failures, so it doesn’t waste time trying to fix a broken test harness when the code is fine.

It’s in public alpha and installs via a curl script on macOS/Linux or PowerShell on Windows. The pitch is recovering from red builds faster and giving every engineer senior-level analysis context. Whether it actually delivers senior-level insight is an open question, but the self-hosted angle is a genuine differentiator for teams that can’t send code to a third-party API.

The Megakernel Comeback Story

Source: together.ai ↗

Together AI’s post about deleting its megakernels is a lesson in engineering humility. Last year they built single fused GPU kernels for an entire model forward pass. This year they deleted them. The discovery: using CUDA Graphs and PDL on top of default Torch Inductor kernels recovered 98% of megakernel performance without writing any custom kernels. Then, with “multi-kernels” and agent loops, they beat their old megakernels by up to 1.7x, achieving over 1100 TPS for Llama 1B on H100.

The lesson isn’t that custom kernels are bad - it’s that hand-written assembly is a maintenance burden that often isn’t worth the marginal gain. The default Inductor kernels plus CUDA Graphs got them 98% of the way there. The last 2% wasn’t worth the complexity. This led to Together Compiler, a framework for continual AI inference optimization. If you’re writing custom CUDA kernels for inference, benchmark against the defaults before you commit to that path.

Traffic Mix: The Load Test Variable Everyone Ignores

Source: brooker.co.za ↗

Brooker’s post on workload mix is short but important. Microsoft’s preliminary report on last week’s M365 outage blames a failure to detect the issue on the specific traffic mix and SKUs used in testing labs. Using a simulator, Brooker shows that a skewed (Zipf) key distribution can either decrease throughput in a lock-contention model or increase it in a cache model, depending on the system. Throughput can vary by multiple orders of magnitude depending on key skew.

The lesson: load tests must accurately reflect production traffic patterns to be meaningful. If your production workload has hot keys and your load test uses uniform distribution, your results are fiction. This is the kind of thing that causes outages that “came out of nowhere” - the system was fine in testing because the testing didn’t look like production.

GitHub CLI Stops Polling

Source: github.blog ↗

GitHub CLI v2.105.0 adds Event Streams support, letting scripts wait for pull request events with a single command. The gh event listen command creates a subscription and prints each event as JSON, exiting after the first event by default. Options include --count, --follow, and --timeout. You can wait for submitted reviews, state changes, merge conflicts, and completed check suites.

This replaces the polling pattern that every CI script has - check for a review, sleep, check again. It’s in preview and requires access to the Event Streams waitlist, but it’s the right direction. For anyone writing automation around PR workflows, this eliminates a whole category of race conditions and wasted API calls.

GitLab 19.6 Ships AI Governance

Source: docs.gitlab.com ↗

GitLab 19.6 landed on November 19 with features aimed at AI governance. Audit events for MCP server tool calls are now available in AI > Governance, recording who did what, to which resource, and when. GitLab Duo in Slack lets you mention @GitLab to turn conversations into issues or summarize discussions. Owners can control which MCP server tools AI agents can use, with rules enforced for every client.

The audit events are the meaningful feature here. As AI agents get more autonomy in CI/CD pipelines, knowing exactly what they did is non-negotiable. The MCP server tool controls give owners a way to constrain what agents can touch. This is the kind of governance that security teams have been asking for.

Get the brief

Liked this one? Pick the beats you care about and get just those, five minutes a morning. Free, no hype, one click to leave.

About Me Author

My name is

BriefTechNews

A daily digest of what actually moved in AI, tech, crypto and fintech, assembled and written with AI, with every item linked to its source. Read More
Tags

You May Also Like