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.
aja12 3 days ago [-]
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.
pron 3 days ago [-]
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).
ekidd 3 days ago [-]
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.
nsagent 3 days ago [-]
Do you use core abstractions like Vec, String, Box, Arc, and Mutex? If so, those are built using unsafe code internally.
jerf 3 days ago [-]
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.
afdbcreid 3 days ago [-]
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.
teaearlgraycold 3 days ago [-]
Unsafe rust is still safer than normal C.
tialaramex 3 days ago [-]
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_uppercase 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.
Edited: We're talking about uppercase, they're basically mirrors, but we should choose the uppercase function.
nsagent 3 days ago [-]
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.
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.
pron 3 days ago [-]
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.
millerm 3 days ago [-]
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.
pron 3 days ago [-]
> 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).
As for native C/C++ libraries (outside the JVM itself), Java programs do use some, but generally not more than Rust programs.
afdbcreid 3 days ago [-]
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.
pron 3 days ago [-]
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.
afdbcreid 3 days ago [-]
> 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.
pron 3 days ago [-]
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.
pjmlp 3 days ago [-]
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.
charcircuit 3 days ago [-]
>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.
vips7L 3 days ago [-]
You don’t think there’s some intrinsic code in llvm that would be generating assembly that doesn’t match Rust’s safety rules?
tialaramex 3 days ago [-]
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 prefer here, so e.g. None for Option<char> went from 0x0011_0000 to the bit pattern 0xFFFF_FFFF and now that same LLVM bug 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.
gavinray 3 days ago [-]
Take a peek into the Rust stdlib method implementations. The lang is built on a house of "unsafe".
afdbcreid 3 days ago [-]
So is the JVM, and?
rurban 2 days ago [-]
And they are unsafe, marketed as safe. Liars
Thaxll 3 days ago [-]
Rust is as vulnerable as the Java issue l, if you use simd you're in the same boat.
afdbcreid 3 days ago [-]
Actually, Rust can have fully safe SIMD (Java too, but it's still in preview AFAIK).
empath75 3 days ago [-]
we have like a million lines of rust in production right now and zero unsafe.
InsidiousWombat 3 days ago [-]
That's just not correct
pron 3 days ago [-]
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.
slopinthebag 3 days ago [-]
is there a java runtime not written a memory unsafe language? because if so, by your own standards java is entirely unsafe
insanitybit 3 days ago [-]
> 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++.
pron 3 days ago [-]
> 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). Of course, there's nothing slow in Java code; it compiles like C or C++ or Rust or Zig, sometimes with more aggressive optimisations and sometimes with less aggressive ones. Unsafe mostly used to be used for certain memory operations before VarHandles and FFM.
> 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).
insanitybit 3 days ago [-]
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 contains 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.
pron 3 days ago [-]
> 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.
insanitybit 3 days ago [-]
> 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.
fulafel 3 days ago [-]
JIT vs AOT doesn't really make a difference in this context.
insanitybit 2 days ago [-]
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.
ninkendo 3 days ago [-]
OP didn’t say anything about Rust, by the way. This post comes off as being defensive about a point nobody made.
supersimpleguy 3 days ago [-]
…it was a metaphor to agree with the OP’s point.
Not everyone on the web is looking to start an argument; some people use literary devices to reinforce their point. If anyone is defensive about a point nobody made, it’s you.
zamadatix 3 days ago [-]
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.
pjmlp 3 days ago [-]
Of course, it is all about reducing the blast size when something goes up.
rurban 2 days ago [-]
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.
cerved 3 days ago [-]
You're conflating Java with the JVM but sure.
GTP 3 days ago [-]
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.
jpardoe 3 days ago [-]
Is it not theoretically possible, even if it comes at the cost of performance?
anthk 3 days ago [-]
Rust it's far better than Java. Since the old times Java was seen as a CVE generating machine for GNU/Linux environments.
dcminter 3 days ago [-]
This ... isn't true? A lot of people perceived the Java plugin as being insecure in the browser, and indeed it was.
The perception of Java as being insecure on the server was only a thing amongst those who hadn't used it much since the Java plugin era.
That's why the Log4j vulnerability was a huge deal.
I like Rust, but this kind of anti-Java-think is super dated and boring.
cowlevel 3 days ago [-]
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.
hunterpayne 3 days ago [-]
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.
tialaramex 3 days ago [-]
> 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, just the SC/DRF proof, 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.
anthk 3 days ago [-]
>PPS The Java memory model is just superior to Rust's in every way...deal with it.
You forgot the interpreter itself. Good luck.
toastal 3 days ago [-]
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.
jjgreen 3 days ago [-]
Heretical
nr378 3 days ago [-]
[flagged]
meowface 2 days ago [-]
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.
boomlinde 3 days ago [-]
From my understanding it's only a single byte overflow if your payload only contains a single ß.
tptacek 3 days ago [-]
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!)
jascha_eng 3 days ago [-]
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.
tptacek 3 days ago [-]
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.
boomlinde 3 days ago [-]
Yeah that seems right on a second look
yuliyp 3 days ago [-]
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.
_3u10 3 days ago [-]
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.
aftbit 3 days ago [-]
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.
pjmlp 3 days ago [-]
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!
miohtama 3 days ago [-]
This is bad news for C/C++
lionkor 3 days ago [-]
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.
stouset 3 days ago [-]
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.
lionkor 2 days ago [-]
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.
pjmlp 3 days ago [-]
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.
indemnity 3 days ago [-]
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++.
lionkor 2 days ago [-]
> 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.
xnickb 3 days ago [-]
This is bad news for computer industry. See the recent Java4Shell.
eecc 3 days ago [-]
because the assembly for the base64 decoding was handwritten, the paren't comment is still valid
dingaling911 3 days ago [-]
I think the point is that the weakest link WILL be found.
ecshafer 3 days ago [-]
Good news for the computer industry employees though.
anthk 3 days ago [-]
At least C folks can use something like BoehmGC and calm down things a little.
pjmlp 3 days ago [-]
BoehmGC is 40 years old by now, it hasn't been for lack of opportunity.
trismegisti 3 days ago [-]
But are those generic exploits, that don't rely on specific dynamic library and kernel versions? i doubt it.
zamadatix 3 days ago [-]
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.
sick_of_slop 3 days ago [-]
[dead]
circularfoyers 4 days ago [-]
Thought this was another vulnerability for a second, but for anyone else who thought the same, this is already covered in the Ruby advisory being discussed here https://news.ycombinator.com/item?id=50554038 (which covers six other vulnerabilities).
djha-skin 3 days ago [-]
I remember being a kid in a small town. My dad got into an auto accident, and the next day the DJs talked about it on the radio. Then we moved to the Chicago area and the morning news only ever talked about how many accidents we'd see that day on our theoretical morning commute during the traffic segment.
At what point will we stop considering individual x2shell ultra-critical CVEs news in the age of AI? Like, how many of these are we finding per hour?
edelbitter 3 days ago [-]
Hopefully, one step towards that is adapting our release atom feed & patch rollouts procedure. So we can apply upstream's "disable feature XYZ unless marked critical locally then P3, otherwise P2" recommendation before having a human check whether the full patch compiles from source / does not contain new supply chain risks / does not come with relevant regressions / ..
When we arrive at that stage, then we can work down the list of disabled-until-patched components for everything that has already been prepared for emergency shutdown. Not on-call, but at the next convenient schedule. Then its just a number of open items for the day, not a disruption.
goodmythical 3 days ago [-]
you're listening to Bob in the Morning! Today's forecast calls for mixed showers and a scattering of zero-days during the afternoon commuter window followed by at least one outage during rush-hour, stay tuned for Alice's evening show for a preview of tomorrow's forecast!
barbegal 3 days ago [-]
More interested to see how you can use just a single byte overflow to trigger RCE. Definitely achievable but sounds tough.
cyphar 3 days ago [-]
There was an even more restrictive single NUL byte heap overflow in glibc in 2014 that the ProjectZero folks managed to turn into ACE and thus an LPE in setuid binaries[1]. The final section that talks about bickering over exploitability seems particularly pertinent today.
The simplest core mechanism of these kinds of exploits is that you can groom the heap by triggering lots of similar-sized allocations, so you have a good guess as to what the heap will contain where your wild write occurs, and then you can trigger specific allocations to land juicy victim structs in the heap where you want them.
It's an evolution of the old "nop sled" idea from stack overflows (and viruses before that), where you don't know exactly what the stack addresses you're targeting are, but you can in your exploit trigger payload include data that will carpet bomb the stack with NOP instructions so that you have a big window to guess.
kyledrake 3 days ago [-]
I was under the impression that everyone adopted the OpenBSD randomized memory heap by default. Does this imply that it's not enough to prevent this sort of attack from working? If this is even slightly repeatable then the mechanism doesn't seem to be sufficiently random. I'm not an expert on low level memory allocation but at a high level it seems like we need to do a better job of randomizing the heap if this sort of thing is still possible.
tptacek 3 days ago [-]
All the heaps are (probably) randomized. I haven't seen an exploit for this (but know them to exist). ASLR is not a reliable countermeasure for these kinds of flaws. Here's a good starting point:
To be able to effectively turn a single byte overwrite into ACE is still challenging because you will corrupt outside of your buffer, but this corruption must be meaningful.
I would be curious to see how they were able to exploit it here.
Exploitation conditions are likely more challenging today but that’s the earliest reference I know for exploiting a single byte overflow.
valleyer 3 days ago [-]
The commit message for the Ruby fix says it's a heap buffer, so frame pointer smashing would not apply here.
F30 3 days ago [-]
Exactly, these advanced heap exploitation techniques are a relatively new development (last decade or so) and were not even remotely known in 1999. Most of the developments were driven by browser exploitation.
enjoytheview 3 days ago [-]
The next byte in the heap might be the size of an allocation, so if you overwrite it and then free that other allocation, the heap code will think that there is a very large free area there instead of a small one, once you allocate that, you now have a very large heap overflow and can do more fun things. That is just one idea, there are many other ways.
t1234s 3 days ago [-]
For people who haven't been to Germany the character that looks like a script B is pronounced like "S". Its a bit of humor in what is an annoying problem.
echoangle 3 days ago [-]
> pronounced like "S"
Yes, but it's always pronounced "sharp" (like the hiss of a snake), so the letter is used to disambiguate some words. In some contexts (switzerland, capital writing until the capital ß was introduced), it's replaced by ss but then there could technically be two meanings, for example "Maße" is measurements and "Masse" is mass, although most of the time it's clear from the context.
t1234s 3 days ago [-]
Now that I think about it the pronunciation of "ß" is important for people to know who don't speak German but want to order wine when visiting. Say weiss not weib.
pjmlp 3 days ago [-]
We have lots of similar problems in Portuguese, where the context changes meaning, especially since the new orthography removed some accents, however the words are still pronounced differently dependending on the context.
For example côr (colour) is now written cor, however it is still pronounced as if it was written côr, although by the regular rules, given the word has no explicit accent now, it should be spoken as if it was written cór, gotta to love language exception rules.
t1234s 3 days ago [-]
Weiß => Weiss
makemefundyou20 3 days ago [-]
just makes it difficult to search for us.
mimischi 3 days ago [-]
iOS Safari will find „ß“ when you search for “ss”. Not hard at all!
hunterpayne 3 days ago [-]
The Swiss don't use it. Its also not on most people's keyboards. So great to make a command require a special unicode character, letting in yet another attack vector (and requiring us to scan code for letters that don't look quite right). Reminds me of the single char => operator in Scala which has fallen out of use thankfully.
PS There was a movement about multi-lingual/multi-charset programming several decades ago. The international programming community killed it more multiple good reasons. Its not cute, stop doing it.
ok123456 3 days ago [-]
The Duden reform of 1995 removed most of its uses.
OoooooooO 3 days ago [-]
That was a sad day.
We finally got an official uppercase ẞ a few years ago, all glory to ß & ẞ. Maybe my next passport will already have an ẞ instead of ß.
BigTTYGothGF 3 days ago [-]
> So great to make a command require a special unicode character
What command? Also perhaps you missed this part of the article:
> The same loop is in several ISO-8859 and Windows-125x encodings and has been there since Ruby 2.4.0. It is reached by upcase, swapcase, downcase(:fold) and casecmp?.
> UTF-8 strings take a different code path and are not affected.
Panzerschrek 4 days ago [-]
I suppose this function has been written first in assumption, that case conversion doesn't affect length, but later ß -> SS conversion has been added without proper testing.
johnp_ 3 days ago [-]
There was never any guarantee that case conversion is byte length equivalent. Except for pure ASCII, that's just been an incorrect assumption from the start.
debugnik 3 days ago [-]
This only affects ISO-8859-1~16 encodings, Ruby only supports non-ASCII case folding for those and UTF. It might actually be the only character from that list of ISO encodings for which the length changes.
K0nserv 3 days ago [-]
It looks like the original author did actually try to account for this by allocating 20 more bytes than the input length.
From the blog post:
The output buffer is allocated as the input length plus 20 bytes. Each ß adds one byte to the output, so an input with 21 of them overflows the buffer by one byte.
rob74 3 days ago [-]
Ah, so that's the real reason "ß" is now allowed in uppercase too (https://en.wikipedia.org/wiki/%C3%9F)? Reducing the risk of security issues by removing an edge case?
pwdisswordfishq 3 days ago [-]
The Unicode case mappings are covered by backwards-compatibility guarantees. "ß" is going to be mapped to "SS" forever.
OoooooooO 3 days ago [-]
We finally got uppercase ß = ẞ but .upper() will never work correct forever ...
3 days ago [-]
cubefox 3 days ago [-]
It even seems the "more correct" uppercase form of ß is now ẞ, not SS.
> Traditionally, ⟨ß⟩ did not have a capital form, and was capitalized as ⟨SS⟩. Some type designers introduced capitalized variants. In 2017, the Council for German Orthography officially adopted a capital form ⟨ẞ⟩ as an acceptable variant, ending a long debate.[4] Since 2024 the capital has been preferred over ⟨SS⟩.[5]
edelbitter 3 days ago [-]
>ending a long debate
They did not. Participants from Liechtenstein and Switzerland don't even care about that letter (Swiss orthography does not make use of it), so they are not even a good place to begin such debate.
cubefox 3 days ago [-]
The fact that they weren't participating in the debate doesn't mean the debate didn't end, let alone that it didn't begin.
shevy-java 3 days ago [-]
> It even seems the "more correct" uppercase form of ß is now ẞ, not SS.
But that is wrong. In german I only know of ß aka downcased version.
ẞ seems another character. I have no idea what it is, other than looking
close to ẞ, but it most assuredly is not existing in the german language.
There is simply no uppercased variant. 'ss' is "Doppel-s' - that is not
ß. In german we have "das" (which is the), but it can be "das" or "dass"
depending on the sentence, in particular after a ',' character. I often
misspell it, since I prefer "das", when in reality sometimes one has to
use "dass". But 'ß' is very different to that - to claim that 'ß' is
equivalent to 'ss' is simply incorrect. I have no idea who that
"Council for German Orthography" is, but clearly they don't know anything
about German. Who put that Council in charge of anything? Are these drunks?
The claim that the capital has been preferred, is also factually wrong. Who
is writing all that?
That is not a unified authority for anything. It
is totally unclear to me why the wikipedia article
claims that this is legally binding for anyone.
That's just factually incorrect. Is Wikipedia no
longer proofreading?
mr_mitm 3 days ago [-]
Who are you to decide what does and doesn't exist in the German language? You are no more authoritative than the Leibniz-Institut either.
Edit: The Leibniz-Institut is just the publisher. The author, the Rat für deutsche Rechtschreibung, is legitimized by the German (and six other countries') government.
Edit 2: It's also not illegal to use whatever made up rules you want. Nothing about this is legally binding anywhere.
OoooooooO 3 days ago [-]
Duden is just a normal book from a private company since 1995. It has no meaning at all as a source for anything since then.
mr_mitm 3 days ago [-]
Yes I know, but it is highly regarded and many high reputation organizations choose to use it as a reference. What more can you ask for in this space? There are no final arbitrators of a language. Nothing has a meaning as a source.
OoooooooO 3 days ago [-]
The uppercase ß is official in germany since 2017 and gets more and more used in uppercase writings since 2024 (STRASSE -> STRAẞE).
cubefox 3 days ago [-]
Wikipedia says ẞ is "preferred", which is plausible when an organization with an impressive name declares it preferable. Nobody says it's legally binding.
> I often misspell it, since I prefer "das", when in reality sometimes one has to use "dass".
It's confusing because both can mean "that".
"That is true." = "Das ist wahr."
"He said that it is true." = "Er sagte, dass es wahr ist."
weinzierl 4 days ago [-]
There should be other codepoints other than ß that in principle could be used for a vulnerability like that. There are even ones that expand to three codepoints, like ffi.
stuxf 4 days ago [-]
this relies on specific behavior with how the upcase function worked, the ß is the only one that expands in a way that works for this vulnerability.
weinzierl 3 days ago [-]
Can you elaborate on what makes ß special enough to enable the vulnerability.
A quick search showed that there are other cases in legacy encodings that expand to multiple bytes.
For example 0xEF in ISO 6937 expands to CA BC 4E in UTF-8 after case transformation. Similar to ß this is a case with a single byte legacy encoding with a single lowercase unicode codepoint which has no precomposed upper case equivalent.
debugnik 3 days ago [-]
From the Ruby docs:
> Non-ASCII case mapping and folding are supported for UTF-8, UTF-16BE/LE, UTF-32BE/LE, and ISO-8859-1~16 Strings/Symbols.
ß might actually be the only character that expands to multiple bytes on the original encoding from that list of ISO encodings.
weinzierl 3 days ago [-]
Ah, good point. If ISO-8859-1 is the only supported single-byte legacy encoding then ß is most likely the only case.
EDIT: Thinking about it, my example from above should work with UTF-16 input.
U+0149 is a single lower case BMP codepoint, so two bytes in UTF-16. It has no precomposed uppercase, so it turns into two codepoints and 4 bytes in UTF-8 and UTF-16.
tptacek 3 days ago [-]
I went looking last night and found only the ß in Windows-1252.
edelbitter 3 days ago [-]
I believe these deserve a mention in your unit tests:
1. ÿ (LATIN SMALL LETTER Y WITH DIAERESIS) is in ISO-8859-1, but Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS) is not - however, theres this thing called Windows-1252 which is often treated as equivalent, where it is.. but not in the same place as in ISO-8859-15.
2. The Unicode (and correct) uppercase of µ (MICRO SIGN) is Μ (GREEK CAPITAL LETTER MU) which should look like M (LATIN CAPITAL LETTER M) .. only the latter can be expressed in Windows-1252.
3. The ISO-8859-12 encoding is a lie.
3 days ago [-]
GTP 3 days ago [-]
> We'll be publishing a proof of concept in a week, once people have had time to upgrade.
I think one may now decide to publish the PoC straight away or not publish it at all, since an AI agent pointed at this post would very likely be able to produce one in a few minutes.
speedgoose 4 days ago [-]
But can the attacker specify the encoding in rails? It's not like UTF-8 or GTFO?
CER10TY 3 days ago [-]
You can freely specify the encoding when sending multipart/form-data POST since Rails respects the charset attribute in Content-Type, eg Content-Type: text/plain; charset=Windows-1252
bloak 3 days ago [-]
So you have to convert ISO-2022-JP, for example? That sounds like a disaster waiting to happen.
lmz 3 days ago [-]
Clients have to do the same with server responses.
Browsers stopped auto-detecting ISO-2022-JP for this reason.
pdntspa 3 days ago [-]
This seems so basic that it strikes me odd that we are just now finding it. Does nobody in Germany use Ruby? That character is reasonably common in German.
zelphirkalt 4 days ago [-]
Name as discussed earlier here on Hackernews :) Glad they went with that name.
olejorgenb 3 days ago [-]
I assume Gitlab.com run a fixed version, but it would be good if they could confirm it now..
shipsafestack 3 days ago [-]
[flagged]
FreeBurn 4 days ago [-]
[flagged]
binarybriefing 3 days ago [-]
[flagged]
francuza9 3 days ago [-]
[dead]
lousken 4 days ago [-]
Scheiße2Shell?
wiether 3 days ago [-]
Get ready to upgrade your GitLab instance...
jaapz 3 days ago [-]
Interesting that it takes so long for them to release a patched version
EDIT: 19.6.0 is now out
EDIT2: that version still comes with an unpatched ruby... incredible
wiether 3 days ago [-]
Yeah things are crazy
They released 19.6.0 but it doesn't contains the fixed ruby
There's no information in the OP page to say when/whether companies like GitLab were notified ahead of time, though I would assume they have been. The security workflow and build process for releases at GitLab is quite slow, unfortunately, or at least it was when I worked there (pre-LLMs). It's quite a large process with lots of backporting etc, so if they only found out about it today I'd expect the patch in the next day or two. It should be possible to manually patch the version yourself though that might be awkward depending on the scale of the deployment.
rs_rs_rs_rs_rs 4 days ago [-]
For once a bug name that's cool.
stuxf 4 days ago [-]
we were thinking of naming it ruby off rails haha, but this title ties into how this vulnerability works which was super cool
rs_rs_rs_rs_rs 3 days ago [-]
And the fact that you can almost read it ruby 2 hell
tvvocold 3 days ago [-]
One Shell a Day, Ops Run Away.
pluc 3 days ago [-]
Here come the united statesmen asking about Ruby 2b hell
More like use rails if you're writing it, use rust if you're making a real smart clanker do it.
He made rails for humans not for speed.
jjgreen 3 days ago [-]
... also annexing the Sudetenland, so YMMV.
mikrotikker 3 days ago [-]
Please stop
jjgreen 3 days ago [-]
That's what Poland said.
neko_ranger 3 days ago [-]
we Germans already have a word for this, we call it ruby2ßhellen
3 days ago [-]
matiasdante 3 days ago [-]
Nginx, Java, PHP, and now Ruby...all in the same week. AI is discovering a lot of these things at a rapid pace (or maybe it's just because of all the slop code out there)
realsdx 3 days ago [-]
Another day, another RCE!
srgb_vs_cmyk 3 days ago [-]
It is getting absurd, in span of 48h there is one for nginx, java, php and ruby; with another one for php and ruby in last month.
slekker 3 days ago [-]
DHH in shambles
BigTTYGothGF 3 days ago [-]
Every cloud has a silver lining.
ChristmasTomer 2 days ago [-]
[flagged]
ajainvivek 3 days ago [-]
[flagged]
lost_pointer_an 3 days ago [-]
[dead]
EINFLUSS 3 days ago [-]
[flagged]
sgt 3 days ago [-]
Django next? Although it's unlikely, Django is known to be above average in terms of security by now.
imtringued 3 days ago [-]
The days of people feeling secure because they don't make egregious mistakes are unfortunately over. Now the rule is: You are vulnerable, you just don't know how.
Gigachad 3 days ago [-]
The bug here is in the C code for Ruby. Python is also written in C and just as likely to have memory bugs.
pjmlp 3 days ago [-]
CPython.
jaapz 3 days ago [-]
yes, the version of python that almost everyone uses
pjmlp 3 days ago [-]
Which isn't the language, rather one of its implementations.
BigTTYGothGF 3 days ago [-]
Are non-cpython implementations anything more than a rounding error?
pjmlp 3 days ago [-]
They exist, for longer than a decade, with users.
BigTTYGothGF 3 days ago [-]
> They exist, for longer than a decade
And many of them target a version of python that's at least that old.
> with users
I'm confident they have users, but I don't believe that they exist in quantities beyond, as I said earlier, "a rounding error".
pjmlp 3 days ago [-]
Big enough to still make the point language != implementation.
r_lee 3 days ago [-]
nobody cares if it's only a small %. it's an irrelevant point when thinking about impact.
sgt 13 hours ago [-]
That's incredibly naïve and like saying Haskell has had a minimal impact and as such is irrelevant, due to its 0.01% market share.
DarkNova6 3 days ago [-]
Above average doesn’t cut it these days. And doesn’t Python have some of the strongest exposures to C libraries?
Well…
sgt 3 days ago [-]
Uh oh. I guess it's being hammered with people with Red Team access right now.
jaapz 3 days ago [-]
it's just a matter of time before the first big python RCE will be posted here
sgt 3 days ago [-]
True. However, I think my original point still has some merit as Django does significant validation and cleaning of data.
gsich 3 days ago [-]
no poc. go away.
stuxf 3 days ago [-]
would you rather we publish a PoC for a vulnerability that doesn't even have a patch yet? e.g self-hosted GitLab still hasn't shipped a newer version of Ruby that's patched...
would be wildly irresponsible
3 days ago [-]
jaxn 3 days ago [-]
the patch is to update ruby
0x457 3 days ago [-]
Yeah, but GitLab ships "all in one" packaging that includes ruby.
gsich 3 days ago [-]
Yes. Look at PHP and Nginx which was only "exploitable" by very specific niche conditions. Overhyped security BS by some AI toddlers.
oguz-ismail2 3 days ago [-]
>we
I doubt you have a PoC at all
spikewall 3 days ago [-]
took glm a bit over 20 minutes to write one, based on the report.
Does every crash prove that a RCE can exist? This sounds halting problemy.
jerf 3 days ago [-]
No, every crash does not prove an RCE can exist. However certain types of crashes are smelly enough that it's safest just to assume that someone, somewhere, on some system can probably lift it into an exploit.
I've red teamed some systems locally, and I've found rather a wide variety of issues that I couldn't actually work into a working exploit, either at all or in any reasonable manner that didn't require me to very carefully configure a system in an unrealistic manner just so it could be exploited, but even at a much smaller scale you really just want to fix them rather than worry about them. Defense in depth if nothing else.
tguedes 3 days ago [-]
The authors say that the vuln allows RCE and they will publish a PoC in a week
Rendered at 20:57:05 GMT+0000 (Coordinated Universal Time) with Vercel.
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.
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.
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.
... against str::to_uppercase 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.
Edited: We're talking about uppercase, they're basically mirrors, but we should choose the uppercase function.
> 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...
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).
As for native C/C++ libraries (outside the JVM itself), Java programs do use some, but generally not more than Rust programs.
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.
Assembly provides no timing guarantees. You will want something higher level built on top of assembly that can guarantee it for a specific processor.
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.
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++.
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). Of course, there's nothing slow in Java code; it compiles like C or C++ or Rust or Zig, sometimes with more aggressive optimisations and sometimes with less aggressive ones. Unsafe mostly used to be used for certain memory operations before VarHandles and FFM.
> 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).
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 contains 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.
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.
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.
Not everyone on the web is looking to start an argument; some people use literary devices to reinforce their point. If anyone is defensive about a point nobody made, it’s you.
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.
The perception of Java as being insecure on the server was only a thing amongst those who hadn't used it much since the Java plugin era.
That's why the Log4j vulnerability was a huge deal.
I like Rust, but this kind of anti-Java-think is super dated and boring.
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.
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, just the SC/DRF proof, 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.
You forgot the interpreter itself. Good luck.
(Correct me if I'm wrong!)
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.
Now to get people to use them it's an issue.
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.
> 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.
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.
I would prefer something be impossible by construction.
There are memory-safe options with little/no performance overhead compared to C/C++.
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.
At what point will we stop considering individual x2shell ultra-critical CVEs news in the age of AI? Like, how many of these are we finding per hour?
When we arrive at that stage, then we can work down the list of disabled-until-patched components for everything that has already been prepared for emergency shutdown. Not on-call, but at the next convenient schedule. Then its just a number of open items for the day, not a disruption.
[1]: https://projectzero.google/2014/08/the-poisoned-nul-byte-201...
It's an evolution of the old "nop sled" idea from stack overflows (and viruses before that), where you don't know exactly what the stack addresses you're targeting are, but you can in your exploit trigger payload include data that will carpet bomb the stack with NOP instructions so that you have a big window to guess.
https://azeria-labs.com/grooming-the-ios-kernel-heap/
I would be curious to see how they were able to exploit it here.
Exploitation conditions are likely more challenging today but that’s the earliest reference I know for exploiting a single byte overflow.
Yes, but it's always pronounced "sharp" (like the hiss of a snake), so the letter is used to disambiguate some words. In some contexts (switzerland, capital writing until the capital ß was introduced), it's replaced by ss but then there could technically be two meanings, for example "Maße" is measurements and "Masse" is mass, although most of the time it's clear from the context.
For example côr (colour) is now written cor, however it is still pronounced as if it was written côr, although by the regular rules, given the word has no explicit accent now, it should be spoken as if it was written cór, gotta to love language exception rules.
PS There was a movement about multi-lingual/multi-charset programming several decades ago. The international programming community killed it more multiple good reasons. Its not cute, stop doing it.
We finally got an official uppercase ẞ a few years ago, all glory to ß & ẞ. Maybe my next passport will already have an ẞ instead of ß.
What command? Also perhaps you missed this part of the article:
> The same loop is in several ISO-8859 and Windows-125x encodings and has been there since Ruby 2.4.0. It is reached by upcase, swapcase, downcase(:fold) and casecmp?.
> UTF-8 strings take a different code path and are not affected.
From the blog post:
> Traditionally, ⟨ß⟩ did not have a capital form, and was capitalized as ⟨SS⟩. Some type designers introduced capitalized variants. In 2017, the Council for German Orthography officially adopted a capital form ⟨ẞ⟩ as an acceptable variant, ending a long debate.[4] Since 2024 the capital has been preferred over ⟨SS⟩.[5]
They did not. Participants from Liechtenstein and Switzerland don't even care about that letter (Swiss orthography does not make use of it), so they are not even a good place to begin such debate.
But that is wrong. In german I only know of ß aka downcased version.
ẞ seems another character. I have no idea what it is, other than looking close to ẞ, but it most assuredly is not existing in the german language. There is simply no uppercased variant. 'ss' is "Doppel-s' - that is not ß. In german we have "das" (which is the), but it can be "das" or "dass" depending on the sentence, in particular after a ',' character. I often misspell it, since I prefer "das", when in reality sometimes one has to use "dass". But 'ß' is very different to that - to claim that 'ß' is equivalent to 'ss' is simply incorrect. I have no idea who that "Council for German Orthography" is, but clearly they don't know anything about German. Who put that Council in charge of anything? Are these drunks? The claim that the capital has been preferred, is also factually wrong. Who is writing all that?
Edit: Oh I see, you have that from Wikipedia.
The .pdf can be found here:
https://www.rechtschreibrat.com/DOX/RfdR_Amtliches-Regelwerk...
So from what I can see, this is only the:
"Leibniz-Institut für Deutsche Sprache"
That is not a unified authority for anything. It is totally unclear to me why the wikipedia article claims that this is legally binding for anyone. That's just factually incorrect. Is Wikipedia no longer proofreading?
Edit: The Leibniz-Institut is just the publisher. The author, the Rat für deutsche Rechtschreibung, is legitimized by the German (and six other countries') government.
The Duden is also seen by many as authoritative and also knows and allows the capital ß: https://www.duden.de/sprachwissen/rechtschreibregeln/doppel-...
Edit 2: It's also not illegal to use whatever made up rules you want. Nothing about this is legally binding anywhere.
> I often misspell it, since I prefer "das", when in reality sometimes one has to use "dass".
It's confusing because both can mean "that".
"That is true." = "Das ist wahr."
"He said that it is true." = "Er sagte, dass es wahr ist."
A quick search showed that there are other cases in legacy encodings that expand to multiple bytes.
For example 0xEF in ISO 6937 expands to CA BC 4E in UTF-8 after case transformation. Similar to ß this is a case with a single byte legacy encoding with a single lowercase unicode codepoint which has no precomposed upper case equivalent.
> Non-ASCII case mapping and folding are supported for UTF-8, UTF-16BE/LE, UTF-32BE/LE, and ISO-8859-1~16 Strings/Symbols.
ß might actually be the only character that expands to multiple bytes on the original encoding from that list of ISO encodings.
EDIT: Thinking about it, my example from above should work with UTF-16 input.
U+0149 is a single lower case BMP codepoint, so two bytes in UTF-16. It has no precomposed uppercase, so it turns into two codepoints and 4 bytes in UTF-8 and UTF-16.
1. ÿ (LATIN SMALL LETTER Y WITH DIAERESIS) is in ISO-8859-1, but Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS) is not - however, theres this thing called Windows-1252 which is often treated as equivalent, where it is.. but not in the same place as in ISO-8859-15.
2. The Unicode (and correct) uppercase of µ (MICRO SIGN) is Μ (GREEK CAPITAL LETTER MU) which should look like M (LATIN CAPITAL LETTER M) .. only the latter can be expressed in Windows-1252.
3. The ISO-8859-12 encoding is a lie.
I think one may now decide to publish the PoC straight away or not publish it at all, since an AI agent pointed at this post would very likely be able to produce one in a few minutes.
Browsers stopped auto-detecting ISO-2022-JP for this reason.
EDIT: 19.6.0 is now out EDIT2: that version still comes with an unpatched ruby... incredible
They released 19.6.0 but it doesn't contains the fixed ruby
And the releases feed don't have 19.6.0 https://docs.gitlab.com/releases/all-releases.xml
He made rails for humans not for speed.
And many of them target a version of python that's at least that old.
> with users
I'm confident they have users, but I don't believe that they exist in quantities beyond, as I said earlier, "a rounding error".
Well…
would be wildly irresponsible
I doubt you have a PoC at all
If you are not calibrated with how small a hole it can take to lift a system up into full code execution, I recommend budgeting a couple of hours to spend with https://projectzero.google/2021/12/a-deep-dive-into-nso-zero... and https://projectzero.google/2022/03/forcedentry-sandbox-escap... . I think way too many developers still don't grok what hackers can do, even before AIs. They too often think just in limited terms about the hole itself without understanding where the holes can lead.
I've red teamed some systems locally, and I've found rather a wide variety of issues that I couldn't actually work into a working exploit, either at all or in any reasonable manner that didn't require me to very carefully configure a system in an unrealistic manner just so it could be exploited, but even at a much smaller scale you really just want to fix them rather than worry about them. Defense in depth if nothing else.