News for hackers. Stuff that matters.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by cowlevel on Thursday November 19, 2026 @04:54AM (#50558077)
So the recent RCE wave seems to be people finding more single byte overflows and such, but reporting them as RCEs because AI can do the tedious grunt work of finding the rest of the vulnerability chain.

If any single byte overflow can be converted into an RCE with minimal human effort then we have no choice but to prove the whole software stack is memory safe.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by miohtama on Thursday November 19, 2026 @05:01AM (#50558130)
This is bad news for C/C++
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by xnickb on Thursday November 19, 2026 @05:12AM (#50558203)
This is bad news for computer industry. See the recent Java4Shell.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by eecc on Thursday November 19, 2026 @05:20AM (#50558271)
because the assembly for the base64 decoding was handwritten, the paren't comment is still valid
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by dingaling911 on Thursday November 19, 2026 @05:45AM (#50558442)
I think the point is that the weakest link WILL be found.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by ecshafer on Thursday November 19, 2026 @08:36AM (#50559921)
Good news for the computer industry employees though.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by anthk on Thursday November 19, 2026 @05:59AM (#50558537)
At least C folks can use something like BoehmGC and calm down things a little.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pjmlp on Friday November 20, 2026 @02:16AM (#50571219)
BoehmGC is 40 years old by now, it hasn't been for lack of opportunity.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by lionkor on Thursday November 19, 2026 @06:38AM (#50558852)
The good news is that this was already the case, and we have tools that check for this; like fuzzers and sanitizers.

Now to get people to use them it's an issue.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by stouset on Thursday November 19, 2026 @12:58PM (#50563524)
We have had fuzzers and sanitizers for decades. Despite their widespread use, we still experience a deluge of memory safety issues in memory unsafe languages, including in projects that heavily lean on these tools.

The actual good news is that we have multiple mature languages that entirely remove the need for users to configure and run fuzzers and sanitizers and remember to always obey arcane rules in order to avoid memory corruption.

We’ve been encouraging people to walk, not run, to the exits and switch from C and C++ to memory-safe equivalents. Now it is clear that the time for walking is over and the remaining holdouts should be at the very least jogging if not running.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pjmlp on Friday November 20, 2026 @02:12AM (#50571178)
The problem are the technologies written in them, that we aren't replacing any time sooner.

I work mostly in compiled managed languages, yet have to keep my C and C++ skills sharp, as there is always this or other scenario that requires something written in them, like the runtimes or compiler tools I depend on, because bootstraping is too much work for most implementors.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by lionkor on Friday November 20, 2026 @04:51AM (#50572421)
Yes, but to quote an earlier comment:

> Let's say you rewrite your terminal emulator in Rust from C or C++; you'll first undo decades of bug fixes, compatibility decisions, quirks, etc. which you WILL have to deal with eventually. This essentially puts you back at least a decade, because these issues take users using the software to point out to you before they're fixed. The only benefit of this whole game being that you get memory safety. These teams are never the original teams, which is the source of the problem. A rewrite can only succeed if it's a result of all the learned failures and shortcomings of the original, otherwise it's bound to repeat every single mistake and add more on top.

> And you don't even deliver memory safety to the users of the original this way, because people won't use the rewrite, because it's buggy, incompatible, etc.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by indemnity on Thursday November 19, 2026 @03:52PM (#50566195)
Ah yes, the "programmers just need to be better" argument.

I would prefer something be impossible by construction.

There are memory-safe options with little/no performance overhead compared to C/C++.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by lionkor on Friday November 20, 2026 @04:54AM (#50572446)
> Ah yes, the "programmers just need to be better" argument.

That's not what I said, don't put words in my mouth.

And yes, programmers need to do better. That's not the answer, but the quality of code that the average programmer outputs is abysmal and could be a lot better simply by giving a shit :D

You can avoid a lot of memory issues in C++ already, yet so many people refuse to use these features (like std::array, boost::synchronized_value, std::unique_ptr). If we used these, we wouldn't solve all memory issues, but we would surely have less.

If you interpret me saying "we should do better" as "we don't need Rust because programmers just need to not make mistakes" then I think the ball is in your court.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by trismegisti on Thursday November 19, 2026 @05:05AM (#50558157)
But are those generic exploits, that don't rely on specific dynamic library and kernel versions? i doubt it.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by zamadatix on Thursday November 19, 2026 @06:13AM (#50558631)
The problem now is it really doesn't matter as much. Before you had to put the work in to make the exploit chain work in the specific situation. Now you just need the entry point through the narrow hole in the exposed portion and a target set worth the tokens to customize it to work against one of the individual deployments. At least until we get better at making it difficult to chain things in response.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by boomlinde on Thursday November 19, 2026 @05:14AM (#50558222)
From my understanding it's only a single byte overflow if your payload only contains a single ß.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by yuliyp on Thursday November 19, 2026 @06:17AM (#50558661)
From the pseudocode it's always a single byte. Desyncing before the end of the buffer is fine. Desyncing at the very end causes the single byte overflow.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tptacek on Thursday November 19, 2026 @09:38AM (#50560698)
No, from my read of the code, it's a single-byte overflow because the casing code works 1 character at a time and doesn't account for the ß->SS expansion case. Not only is it a single byte, but that single byte has a fixed value; you can't use ß->SS to push some other character off the end of the string.

(Correct me if I'm wrong!)

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by jascha_eng on Thursday November 19, 2026 @12:07PM (#50562814)
No this is correct I think. And it's not easy to control what lives next to that buffer. But AI probably can figure out a chain of requests that this then changes the length block of another object or flips a pointer or something, so it's tedious but can be used to escalate to basically arbitrary memory corruption. That's kinda the issue with AI, this would have been extremely tedious to exploit before LLMs but now anyone with an unlocked good enough model can do it.

That's why hiding the POC still helps a bit, because any model probably will require quite a bit of wall clock time to actually build one itself. Then making that work on e.g. a running gitlab instance with other traffic... much harder yet again I'd assume since that should alter memory state without you having control over it.

Still if someone builds an exploit with even 1% success rate they just need to run it on enough instances in parallel and will eventually break through some of them probably.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tptacek on Thursday November 19, 2026 @01:01PM (#50563569)
Right, I'm not talking down the severity of the vulnerability; if anything I think people are underrating it. But it's a constrained 1-byte overflow.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by boomlinde on Thursday November 19, 2026 @02:57PM (#50565418)
Yeah that seems right on a second look
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by toastal on Thursday November 19, 2026 @05:32AM (#50558346)
I like your comment since it points out that we need to enforce the memory situation—but it doesn’t prescribe Rust is the only solution.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by jjgreen on Thursday November 19, 2026 @06:24AM (#50558735)
Heretical
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by aja12 on Thursday November 19, 2026 @05:41AM (#50558409)
It's important to note that Java, like Rust, is generally seen as a memory safe language. But it has bits of assembly, just like Rust has unsafe blocks, to handle some operations. Hence the Java2shell recent vulnerability. Granted Rust may have less need for them and more facilities to audit them, but it is not by itself a panacea that will fix all memory issues. In essence, there is no software stack that is fully memory safe, it is more a matter of restricting the memory unsafe parts in fewer, more scrutinized, better contained sections.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by zamadatix on Thursday November 19, 2026 @05:47AM (#50558454)
Yeah, "memory safe" goes out the window if you prefer to implement parts in assembly. This is where portable SIMD (e.g. the Java vuln was from SIMD), which is abstracted & safe but not necessarily as performant as it could be, is becoming a more reasonable trade off.

Of course I'm not sure how much it counts to be "using a memory safe language" when you have to call put to unsafe code anyways. I.e. just because the library you'd like to use is C but the rest of your project is Rust doesn't mean you're really using a me ory safe language, it means you're sometimes using one. We have a long way to go before environments allow using memory safety fully I think.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by anthk on Thursday November 19, 2026 @05:58AM (#50558531)
Rust it's far better than Java. Since the old times Java was seen as a CVE generating machine for GNU/Linux environments.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by dcminter on Thursday November 19, 2026 @06:25AM (#50558743)
[delayed]
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by cowlevel on Thursday November 19, 2026 @06:28AM (#50558772)
Java CVEs were mostly holes in Java's own sandbox (e.g. used to run multiple applets from different websites in the same VM) which has been abandoned.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by hunterpayne on Thursday November 19, 2026 @09:22AM (#50560487)
Complete nonsense. Many of the CVEs for Rust are things that just can't happen in the JVM. And many of the Java CVEs require uses of the JDK that few people ever use. You can dynamically load classes in the JVM (or you can turn that off). Its a nice feature that isn't used all that often anymore but when you need it, its very powerful. Lots of security folks made a living reporting CVEs around that. But its also why people are salty about CVEs and Java because they just reported the same security "hole" over and over again. Yes the JVM can load classes dynamically. If you don't need that, turn it off (or sign your jars). But if you do need it, then the CVE is largely irrelevant. That security researchers created this false impression of Java is a big part of why bug bounty programs aren't very popular anymore. Crying wolf gets you put on the ignore list.

PS Its the height of irony that the layer protecting Java webservices IS less secure than the Java webservice itself.

PPS The Java memory model is just superior to Rust's in every way...deal with it.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by anthk on Thursday November 19, 2026 @11:27AM (#50562221)
>PPS The Java memory model is just superior to Rust's in every way...deal with it.

You forgot the interpreter itself. Good luck.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tialaramex on Thursday November 19, 2026 @11:39AM (#50562403)
> PPS The Java memory model is just superior to Rust's in every way...deal with it.

I don't see it. In Safe Rust we can't write a Data Race so we get SC/DRF because we know we don't have a data race. If we write unsafe Rust we do need to be careful not to break the rules and introduce a data race.

In Java we do not get such a promise at all, any of our code might race. However, if we do lose Sequential Consistency we still have defined behaviour, we probably no longer understand how our program behaves (if it's not trivial) but we can say e.g. "I didn't write any code to delete the database" and so conclude it doesn't delete the database.

This doesn't seem like a clean win. I can see valuing either proposition more, but "in every way" I don't get that.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by ninkendo on Thursday November 19, 2026 @06:05AM (#50558573)
[delayed]
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @07:12AM (#50559102)
Because safe Rust is so constrained, Rust relies on unsafe much more than Java, and their need for intrinsics is about the same (although Java lets you turn off individual intrinsics at runtime).
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by ekidd on Thursday November 19, 2026 @07:34AM (#50559290)
Tons of production Rust systems use very little unsafe. I've been writing production Rust since 2015, and in that time, I wrote maybe 30 lines of unsafe production code. (Most of it in Tokio primitives.)

Now, in web-facing systems, the biggest concern is the low-level crypto libraries, which need to be written in assembly to avoid timing attacks. These (and related libraries) have seen multiple security advisories in the past year, some related to unsafe (I think?) and some related to logic errors. But overall, those advisories have mostly been lower priority, or affected mostly niche use cases.

If you only have a small amount of unsafe code, then it's possible to audit it more aggressively. And there's only a limited amount of space for bugs. So what I would expect for Rust is a trickle of security bugs, many of them niche or low severity, that slows down with time.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by vips7L on Thursday November 19, 2026 @08:12AM (#50559655)
You don’t think there’s some intrinsic code in llvm that would be generating assembly that doesn’t match Rust’s safety rules?
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tialaramex on Thursday November 19, 2026 @08:38AM (#50559950)
We know LLVM has miscompilation bugs. Sometimes it is practical for Rust to fix those bugs and so it carries patches for LLVM, but in some cases LLVM IR semantics are just incoherent nonsense. An example of the former (Rust carries patches): LLVM got confused about discriminants when Rust uses niches, when the niche bit pattern used was usually right next to the legitimate values for a type the bug in LLVM caused little notice, it could corrupt data but probably not. However Rust changed which bit patterns to use here, so e.g. None for Option<char> went from 0x0011_0000 to the bit pattern 0xFFFF_FFFF and now that same LLVM bugs caused crashes as values which had previously been very slightly wrong were instead hugely wrong.

For an example of the latter (LLVM is just nonsense): LLVM still today has a bug found years ago where pointer provenance (a legitimate but hard to think about idea for optimising compilers) accidentally leaks into integers, and so LLVM can end up with two integers a, b which it believes are not equal and yet a - b == 0. Boom.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by nsagent on Thursday November 19, 2026 @08:45AM (#50560032)
Do you use core abstractions like Vec, String, Box, Arc, and Mutex? If so, those are built using unsafe code internally.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tialaramex on Thursday November 19, 2026 @09:06AM (#50560294)
Lets compare what's inside this Ruby bug, a C function rb_str_casemap which is 40-50 lines of C fiddling with pointers and calling into macros that presumably are familiar to Ruby developers but opaque to an outside viewer. Is it fixed? I guess so but I can't see very well to be sure, it was counting stuff before and now it is being more careful, I hope it's correct this time.

... against str::to_lowercase the Rust function which has a single line of unsafe code, with a two line rationale provided to explain why it's OK to do this. As a subject matter expert I agree with the rationale. LGTM.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by nsagent on Thursday November 19, 2026 @11:46AM (#50562512)
This sub-thread in the conversation is about Java, so comparisons to Ruby aren't what's relevant. Here's part of the relevant GP comment.

> It's important to note that Java, like Rust, is generally seen as a memory safe language. But it has bits of assembly, just like Rust has unsafe blocks, to handle some operations.

And according to sources like CISA and the NSA [1], Java is considered memory safe. Furthermore, Rust has been found to have some memory safety issues as well [2]. I think the point to get across is that yes, Rust can help eliminate a very large set of memory safety bugs, but it's prone to issues that other generally considered memory safe languages also have: at some point to do useful work there are going to be unsafe operations. The surface area might be much smaller, so you're likely better off using a memory safe language if you can help it, but it's not a panacea for having layers of security, especially since it means any issue found is likely to affect a large swath of code written in the language because it's in a load bearing area of the language ecosystem.

[1]: https://www.nsa.gov/Press-Room/Press-Releases-Statements/Pre...

[2]: https://www.microsoft.com/en-us/security/blog/2026/11/09/for...

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by tialaramex on Thursday November 19, 2026 @12:21PM (#50562993)
Java's String::toUpperCase appears to be quite a lot more complicated than the Rust but it is at least all Java and thus without careful inspection I can assume it's memory safe.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by teaearlgraycold on Thursday November 19, 2026 @01:30PM (#50564080)
Unsafe rust is still safer than normal C.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by jerf on Thursday November 19, 2026 @01:50PM (#50564412)
Do you run on CPUs based on the von Neumann architecture?

If so, those are built on unsafe operations internally.

Safety is a lot more complicated than "whether it is in an unsafe block of code in Rust". If you insist that an unsafe primitive can not be handled well enough to become "safe" by some definition of safe then you collapse the entire programming language hierarchy into "everything is completely unsafe". Which may, from a certain point of view, be true, but isn't a particularly useful classification scheme.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by afdbcreid on Thursday November 19, 2026 @03:44PM (#50566098)
Arrays in Java (a loose equivalent of `Vec`) is a runtime primitive and implemented in a memory-unsafe language. References (loose equivalent of `Box` and `Arc`) as well. Java's `synchronized` (a loose equivalent to `Mutex`) as well. Those are not good counterexamples.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @09:11AM (#50560355)
I didn't say there's a lot of unsafe (by whatever measure you consider that to be). I said there's a lot more than in Java.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by millerm on Thursday November 19, 2026 @09:40AM (#50560728)
The JVM is written in an unsafe language. That's where these unsafe calls occur. Clients of these APIs have no control there. Java code itself is safe.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @10:57AM (#50561774)
> That's where these unsafe calls occur.

No, it's not. A relatively common case for unsafe in Rust is in data structures. The data structures in the Java runtime are all written in Java and has almost no use of unsafe (there might be a few, but not becsause of language limitation, but because of initialisation order).

As for the JVM, much of it is a compiler. It doesn't matter what language it's written in, as it generates machine code. Indeed, the vulnerability disclosed yesterday was in a compiler intrinsic, but those are just as common in Rust.

Other than that, the other big piece in the JVM is memory management, and it does, indeed, use C and C++ for memory management, but Rust also uses C (the various implementations of malloc/free in whatever runtime the Rust program is using; BTW, some popular malloc/free implementations are almost as big as Java's most complicated GC).

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by afdbcreid on Thursday November 19, 2026 @03:52PM (#50566203)
Not accurate. Most datastructures that use unsafe in Rust are primitives; `Box`, `Vec`, `Rc`/`Arc`, `HashMap` and `BTreeMap`. Of those, only the equivalent to `HashMap` and `BTreeMap` are written in Java, and they can be written in safe Rust as well if you're willing to give up some of the performance (e.g. always initializing - thing that happens in Java as well). More complex data structures (e.g. graphs) can and often are implemented without unsafe at all.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @04:33PM (#50566723)
I know that you can write slow data structures in safe Rust, but the standard library's data structures are supposed to be efficient. Anyway, a quick look at how common unsafe is in Rust vs Java, both in the standard library and in applications, and you'll see that it's much more common in Rust.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by afdbcreid on Thursday November 19, 2026 @03:56PM (#50566251)
> BTW, some popular malloc/free implementations are almost as big as Java's most complicated GC

I'm pretty sure that's incorrect by a wide margin, and that all non-nop GCs java has are as large as at least some popular allocators.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @04:31PM (#50566699)
Then you're in for a surprise. Take a look at TCMalloc and jemalloc. They're almost the size of HotSpot's most complex GC, then non-pause ZGC.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pjmlp on Friday November 20, 2026 @02:09AM (#50571155)
Not all JVM implementations, there are multi-circular implementations in Java, starting with JikesRVM almost 20 years ago already, whose work with the MMtk memory allocator was later inspired a Rust version thereof.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by gavinray on Thursday November 19, 2026 @12:23PM (#50563018)
Take a peek into the Rust stdlib method implementations. The lang is built on a house of "unsafe".
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by afdbcreid on Thursday November 19, 2026 @03:53PM (#50566216)
So is the JVM, and?
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by rurban on Friday November 20, 2026 @01:15PM (#50579292)
And they are unsafe, marketed as safe. Liars
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by charcircuit on Thursday November 19, 2026 @05:34PM (#50567471)
>which need to be written in assembly to avoid timing attacks

Assembly provides no timing guarantees. You will want something higher level built on top of assembly that can guarantee it for a specific processor.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by InsidiousWombat on Thursday November 19, 2026 @08:39AM (#50559953)
That's just not correct
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @09:20AM (#50560463)
You're welcome to compare the prevalence of unsafe in Java and in Rust, both in the standard library and in user code, and you will see that this is very much correct.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by Thaxll on Thursday November 19, 2026 @10:26AM (#50561340)
Rust is as vulnerable as the Java issue l, if you use simd you're in the same boat.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by afdbcreid on Thursday November 19, 2026 @03:54PM (#50566223)
Actually, Rust can have fully safe SIMD (Java too, but it's still in preview AFAIK).
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by insanitybit on Thursday November 19, 2026 @11:12AM (#50561988)
> Because safe Rust is so constrained, Rust relies on unsafe much more than Java, and their need for intrinsics is about the same (although Java lets you turn off individual intrinsics at runtime).

This is silly. Rust also has tooling for dealing with unsafe - tools for proving unsafe code, tools for verifying unsafe code, tools for fuzzing it, etc.

Java, and other languages like it, often drop into unsafe code where it's far weirder and less supported because they have to because the languages are too slow to do the work they want to do.

And obviously you have all of the complexity of a massive, JIT'd runtime written in C++.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @11:32AM (#50562295)
> Java, and other languages like it, often drop into unsafe code where it's far weirder and less supported because they have to because the languages are too slow to do the work they want to do.

No, that's not been the case for a while, at least since the introduction of VarHandles and FFM (which is why Unsafe is now in the process of being removed altogether).

> And obviously you have all of the complexity of a massive, JIT'd runtime written in C++.

No, that's also inaccurate. The "massive runtime" is largely a compiler (and it doesn't matter what language that's in), and memory management, where the Rust runtime is also about as massive and written in C (the various malloc/free implementations).

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by insanitybit on Thursday November 19, 2026 @06:24PM (#50568028)
This is nonsense. Java doesn't "compile like C or C++ or Rust or Zig" any more than Python does. "Python compiles to bytecode! you can use mypyc!" who cares? That's obviously not the point.

Unsafe is still plenty prevalent in Java, nor is the use of C++ libraries.

> sometimes with more aggressive optimisations and sometimes with less aggressive ones.

Yes, well, that's some handwaving.

> Unsafe mostly used to be used for certain memory operations before VarHandles and FFM.

Yes. It is still very prevelant.

> No, that's also inaccurate. The "massive runtime" is largely a compiler (and it doesn't matter what language that's in), and memory management, where the Rust runtime is also about as massive and written in C (the various malloc/free implementations).

Ridiculous. "largely a compiler" - it's a JIT compiler, as in it's a runtime compiler that allocates executable code at runtime and then runs it. (a) Of course it matters what language it's in (b) JITs are an incredible source of security issues and have their own set of mitigations that have to be applied.

> where the Rust runtime is also about as massive and written in C (the various malloc/free implementations).

A ridiculous comparison.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pron on Thursday November 19, 2026 @09:05PM (#50569261)
> This is nonsense. Java doesn't "compile like C or C++ or Rust or Zig" any more than Python does.

It really does, though. Perhaps you're unfamiliar?

> Unsafe is still plenty prevalent in Java, nor is the use of C++ libraries.

My statement was that unsafe is much more prevalent in Rust than in Java, and that is true.

> Yes, well, that's some handwaving.

I'm sorry that I can't teach you principles of compilation here, but feel free to dig deeper.

> Yes. It is still very prevelant.

Much less than in Rust.

> Ridiculous... A ridiculous comparison.

You don't sound like either a runtime or compiler engineer at all, or you wouldn't have found any of this ridiculous in the least (or news). In that case, I hope that telling you that what I wrote was true might enrage you enough to learn more about these subjects, and perhaps our community will have grown by another member.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by insanitybit on Thursday November 19, 2026 @11:23PM (#50570139)
> It really does, though. Perhaps you're unfamiliar?

You won't be specific so now you're putting me in a position to have to build your argument for you. It's frustrating because the conversation is already stupid. Java is a language so calling it compiled or interpreted or AOT or JIT is already a mistake, those are implementation properties of how it is deployed.

The massively most popular implementations rely massively on JIT, even if they have varying levels of AOT support.

This is so obviously different from actual AOT languages. Hence having to call it AOT when it's Java.

> My statement was that unsafe is much more prevalent in Rust than in Java, and that is true.

That's an empirical claim. You can go ahead and support it.

> Much less than in Rust.

Riiiight. No one uses Netty, right????? They had such an easy job ditching Unsafe, right??????

> You don't sound like either a runtime or compiler engineer at all, or you wouldn't have found any of this ridiculous in the least (or news). In that case, I hope that telling you that what I wrote was true might enrage you enough to learn more about these subjects, and perhaps our community will have grown by another member.

And I recognize your name well enough that you don't know much of anything.

Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by fulafel on Friday November 20, 2026 @01:00AM (#50570722)
JIT vs AOT doesn't really make a difference in this context.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by insanitybit on Friday November 20, 2026 @09:37AM (#50575230)
It makes a huge difference. JIT has major implications for security. It requires its own distinct mitigation techniques because it necessitates runtime code generation and execution. It's extremely complex.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by empath75 on Thursday November 19, 2026 @01:27PM (#50564029)
we have like a million lines of rust in production right now and zero unsafe.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by slopinthebag on Thursday November 19, 2026 @05:07PM (#50567127)
is there a java runtime not written a memory unsafe language? because if so, by your own standards java is entirely unsafe
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by GTP on Thursday November 19, 2026 @07:34AM (#50559293)
Yes, ultimately it is about reducing the attack surface so that we get less exploits and also more reliable software (overflows can cause sporadic crashes). Still very much worth doing it IMO, even tough it doesn't sove all problems on its own. Apply defence in depth and combine this with other mitigation techniques. This is the path if you want robust systems.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by cerved on Thursday November 19, 2026 @09:01AM (#50560228)
You're conflating Java with the JVM but sure.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by jpardoe on Thursday November 19, 2026 @10:29AM (#50561384)
Is it not theoretically possible, even if it comes at the cost of performance?
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pjmlp on Friday November 20, 2026 @02:04AM (#50571127)
Of course, it is all about reducing the blast size when something goes up.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by rurban on Friday November 20, 2026 @01:13PM (#50579274)
Of course there are software stacks which are fully memory safe. You just won't like them, as they involve a GC, and no Java-like hacks.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by _3u10 on Thursday November 19, 2026 @07:12AM (#50559103)
I don’t think it’s a single byte at least not in this case, you’d put your shell code into a string and then use enough double S to push it where it needs to go. I’m assuming each double S pushes one more byte.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by aftbit on Thursday November 19, 2026 @06:33PM (#50568101)
That may be necessary but it won't be sufficient. Memory safety breaks down at the edges. You can't trust the hardware (see Spectre or Rowhammer). Besides, even if the whole world were memory safe, with no buffer over/underflows or use after free or anything like that, you'd still get logic bugs like the recent sshhole.
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by pjmlp on Friday November 20, 2026 @02:06AM (#50571136)
Note that systems that predate UNIX and C for a decade, already used security as selling point, some of them are still around, e.g. Unisys ClearPath MCP, born as Burroughs, with NEWP as systems programming language, one of the very first with unsafe code blocks, in 1961!
Re:Ruby2ßhell: Pre-authentication RCE on stock Rails by meowface on Friday November 20, 2026 @09:00AM (#50574766)
Even if LLMs were never invented, the Rust proponents were obviously completely right from the start. It was a silly state of affairs that, for decades, (performant) software was not memory-safe by default. The price was always going to one day be paid on that.