It’s a privilege escalation.
The vulnerability, tracked as CVE-2024-1086 and carrying a severity rating of 7.8 out of a possible 10, allows people who have already gained a foothold inside an affected system to escalate their system privileges. It’s the result of a use-after-free error, a class of vulnerability that occurs in software written in the C and C++ languages when a process continues to access a memory location after it has been freed or deallocated. Use-after-free vulnerabilities can result in remote code or privilege escalation.
rust mentioned, lets goo
Blazingly fast 🚀
Zero-cost abstractions!
This is why least privilege is so important. If one account is compromised it will be harder to compromise others if the original account is isolated.
a use-after-free error, a class of vulnerability that occurs in software written in the C and C++ languages when a process continues to access a memory location after it has been freed or deallocated.
Immediately I noticed how when Teslas can’t drive themselves we also blame the car and not the driver.
Weak. Blame the driver.
I re-wrote my Tesla firmware in Rust. It is faster and more secure. Self-driving is no problem when you use a safe language.
Honestly, why are we even selling cars to people who do not take these basic steps?
I compiled my own drivers
This guy drives not
Yeah, but did you include any biobs?
And then compacted them!
Don’t think C / C++ wasn’t blamed.
And the horse it ride in on!
Outfits that haven’t installed patches since February are getting popped in May by a vuln that was published in January.
Normal technology situations created by normal human behavior. 😜
Outfits? What does it mean in this context?
Organisations
Ahh, thank you
Suits and shit.
Guns for hire
Companies and organizations.
Yet another security issue that Rust would solve.
Oh, we heard, Rust is the greatest invention since sliced bread. We heard it already. Like 65534 times.
Like 65534 times.
So close to full 16-bit max. So close…
Yeah I figured he was going purposely for a memory overflow
Yeah we only need 2 brainRusts more to start seeing some fun.
Gah. I should have stated “I see what you did there.” instead. ;)
Aviation, Health, Space and Car industry have only 3 certified languages that they use. Ada, C and C++. Ada is dying because there are way less young engineers who want to invest their future learning it. Then there is C and C++ but they dont offer memory safety and its really hard to master and its really hard and long (thats what she said) to certify the code when being audited for safety by a tier company.
Rust solves by default (no need to review) like 2/3 of the standard requirements those industries have and are that found in C and C++. Rust will soon be approved in this group by the car industry.
Im not a rust fan, but I have 3 things to say about rust.
- Its fun to program like C++ having the peace of mind knowing the compiler is there helping.
- You dont feel like youre defusing a bomb like when writing C.
- Even though its a fun language to write, its also really hard to master, itd say 2 years to be really proficient with it. There is just so much knowledge.
Aviation, Health, Space and Car industry have only 3 certified languages that they use. Ada, C and C++.
Rust is automotive certified since over half a year. https://ferrous-systems.com/blog/officially-qualified-ferrocene
Could you explain the “no need to review” part? I do keep hearing good things about Rust.
These industries hire third parties to review c and c++ line per line to make sure it’s memory safe. Rust by default forces you to write memory safe code, otherwise it won’t even compile. The rust compiler tells where is the problem and what it expects. No only for basic Type errors but also for concurrent code.
Is it not possible to build that functionality into C/++ compilers?
its the way the language was built. Im not sure its possible without breaking C/C++ which have like 35 years + in the making. Also these concepts are have little to do with programing and more architectural designs. The designers are real engineers working on difficult concepts. All big brains tbh
Ada SPARK is not dying at all, it’s growing. It is used where formal proof is required like and Rust is nowhere near that!
- You dont feel like youre defusing a bomb like when writing C.
Whoa, Skippy. It’s not saving the world, it’s just coding properly.
Well no, those companies deal with really important subjects. Airplanes, car safety, chemotherapy machines, missiles, etc. Have a good day
I wonder how many folks are just refusing to use Rust to spite the Rust Evangelism Strike Team.
Rustaceans 🤝 Vegans
I wait until cargo is actually secure.
What is insecure about it?
It doesn’t verify downloads are authentic. Its an issue with almost all programming dependency managers besides mature ones like Java’s Maven.
Python has been working with Facebook to fix this in pip for like a decade.
But obviously it shows that rust isn’t so concerned about security.
Ah interesting. Thank you, you’re giving me something to read about that I never considered for crates. I guess I just assumed because of the scrutiny Rust was built with and continues to go through that it would also apply to verifying crates. I have definitely heard about it with NPM so it should have been obvious that it might not be any different for crates. Thanks again!
I wish there was a synonym for “evangelism” that began with a “u”.
Urge? Kinda dark and villainous feeling.
Upgrade! “The Rust Upgrade Strike Team! Upgrade Today!” Sounds very propagandistic, almost doublespeak.
Ultimatum? Mildly threatening.
Utopia? It has the self righteous feel.
Uhvangelism, hurhur.
Universalism?
I giggled, thank you.
user
I hate it when people talk about new technologies 🤬
Same. We should head back to ICQ!
eh, still beats Discord as far as I’m concerned
Yeah, but no one will hop on irc or mumble to hang out these days.
Not with that attitude!
I’m already on IRC and XMPP. be the change you want to see.
God I miss the IRC days
Yet another problem that actually updating your shit - which is trivially easy on enterprise Linux - would fix.
It’s part of the 95% of problems solved by actually updating your enterprise Linux host.
unattended-upgrades and forget about it
oops, our third party application broke again
Never happened to me when set to security.
Tell me more (for real, I’m unfamiliar).
Its a Debian package that automatically upgraded packages (if they have pending security updates)
I run mine manually, good to know. Will check it out.
But then I can’t screenshot my 7 years of uptime
Just live patch
Although it is better to have some sort of HA system.
That requires that the patches be in the repos. With RHEL it might be a few months
Normally security patches are pretty good on same day releases as the CVE if available.
Any software can have security issues, including ones written in rust. Just because C/C++ allows one to shoot oneself in the foot doesn’t mean it’s something that’s commonly allowed by anyone with any skill, it’s just a bug like anything else. I swear, people advocating rust believe that it’s something intrinsic in C/C++ that allows such a thing regardless of what a developer does, and it’s getting tiresome.
Of course a good developer can avoid these problems for the most part. The point is that we want the bad developers to be forced to do things a safe way by default.
Even good developers make mistakes. It’s really nice to catch these mistakes at compile time.
But it is, do you not understand what rust brings compared to these two languages ?
A language for noobs that encourages bad style and programming because you can’t shoot yourself in the foot as easily (but you totally still can)? That’s what all these fad languages seem to be, and more keep popping up and declaring themselves the future of programming all the time. Just wait, rust will be forgotten for some other fad language everyone will start using soon enough. Stop reworking everything into the fad language of the moment and just work on existing code.
I’m sorry but this reads like someone that hasn’t used Rust or hasn’t spent much time with it. You’re generalizing Rust with other languages while forgetting that some fads turn into standards.
If everyone stopped trying new things we’d never see progress.
Edit: fixed typo
A language for noobs
That assertion surprises me; I find C easier to use than Rust.
There are still slight advantages to C that probably will make some devs stick to it in specific cases
But this isn’t one of them
Serious question, how would using rust avoid this? Rust still has reference types in the background, right? Still has a way to put stuff on the heap too? Those are the only 2 requirements for reusing memory bugs
This is a use-after-free, which should be impossible in safe Rust due to the borrow checker. The only way for this to happen would be incorrect unsafe code (still possible, but dramatically reduced code surface to worry about) or a compiler bug. To allocate heap space in safe Rust, you have to use types provided by the language like
Box
,Rc
,Vec
, etc. To free that space (in Rust terminology, dropping it by usingdrop()
or letting it go out of scope) you must be the owner of it and there may be current borrows (i.e. no references may exist). Once the variable isdrop
ed, the variable is dead so accessing it is a compiler error, and the compiler/std handles freeing the memory.There’s some extra semantics to some of that but that’s pretty much it. These kind of memory bugs are basically Rust’s raison d’etre - it’s been carefully designed to make most memory bugs impossible without using
unsafe
. If you’d like more information I’d be happy to provide!Thanks for the response. Ive heard of rust’s compiler being very smart and checking a ton of stuff. Its good thing it does, but i feel like there are things that can cause this issues rust cant catch. Cant put my finger on it.
What would rust do if you have a class A create something on the heap, and it passes this variable ( by ref ? ) to class B, which saves the value into a private variable in class B. Class A gets out of scope, and would be cleaned up. What it put on the heap would be cleaned up, but class B still has a reference(?) to the value on the heap, no? How would rust handle such a case?You use lifetimes to annotate parameters and return values in order to tell the compiler about how long things must last for your function to be valid. You can link a specific input with the output, or explicitly separate them. If you don’t give lifetimes the language uses some basic rules to do it for you. If it can’t, eg it’s ambiguous, then it’s a compile error and you need to do it manually.
It’s one of the harder concepts of rust to explain succinctly. But imagine you had a function that took strA and strB, used strB to find a subsection of strA, and then return a slice of strA. That slice is tied to strA. You would use
'a
annotation for strA and the return value, and'b
for strB.Rust compiler will detect the lifetime being shorter than expected.
Also, ownership semantics. Think c++ move semantics. Only one person is left with a good value, the previous owners just have garbage data they can’t use anymore. If you created a thing on the heap and then gave it away, you wouldn’t have it anymore to free at the end. If you want to have “multiple owners” then you need ref counting and such, which also stops this problem of premature freeing.
Edit: one more thing: reference rules. You can have many read-only references to a thing, or one mutable reference. Unless you’re doing crazy things, the compiler simply won’t let you have references to a thing, and then via one of those references free that thing, thereby invalidating the other references.
Thats interresting, thanks! Stuff for me to look into!
I also think halfway through the conversation i might have given the impression i was talking about pointers, while it was not my intention to do so. That said, the readonly/mutable reference thing is very interresting!
Ill look into what rust does/has that is like the following psuedocode :DataBaseUser variable1 = GetDataBaseUser(20);
userService.Users.Add(variable1);
variable1 = null; // or free?
[end of function scope here, reference to heap now in list ]No problem. I’m no guru and I’m currently on Zig but I think learning some Rust is a really fast way to hone skills that are implied by other languages.
It’s not like C where you have control over when you can make references to data. The compiler will stop you from making references in the cases where a memory bug would be possible.
Rust simply doesn’t allow you to have references to data that goes out of scope (unless previously mentioned hoops are jumped through such as an explicitly declared unsafe block). It’s checked at compile time. You will never be able to compile the program.
Rust isn’t C. Rust isn’t C++. The memory-safe-ness of it is also not magic, it’s a series of checks in the compiler.
That sounds odd. That also means that a mapper, command, service,… can never return a class object or entity. Most of the programming world is based on oop o.O
Keep in mind im not talking about the usage of pointers, but reference typed variables.Oh sure, I’m still learning so I thought you meant references as in pointers like in C++. But also, Rust isn’t a strictly object oriented language either. It shares a lot of similar features, but they aren’t all the typical way you’d do things in an OOP language. You should check out the chapter of the Rust book for ownership.
The way I understand it, it is a bug in C implementation of free() that causes it to do something weird when you call it twice on the same memory. Maybe In Rust you can never call free twice, so you would never come across this bug. But, also Rust probably doesn’t have the same bug.
My point is it seems it is a bug in the underlying implementation of free(), not to be caught by the compiler, and can’t Rust have such errors no matter its superior design?
The way that rust attempts to prevent this class of error is not by making an implementation of free that is safe to call twice, but by making the compiler refuse to compile programs where free could be called twice on a pointer.
Anyway, use after free doesn’t depend on a double free. It just means that the program frees memory but keeps the pointer (which now points at memory that could contain unrelated data at some future point in time) and if someone trying to exploit the program finds a way to induce the program to read or write to that memory they may be able to access data they are not expected to, or write data to be used by a different part of the program that they shouldn’t be able to
Thanks, I understand the problem with using memory after it’s been freed and possibly access it changed by another part of the process. I guess I was confused by the double free explanation I read, which didn’t really say how it could be exploited, but I think you are right it still needs to be accessed later by the original program, which would not happen in Rust.
Not really, the issue is that C/C++ is not memory safe, i.e. it allows you to access memory that has already been freed. Consider the following C++ code:
int* wrong() { int data = 10; return &data; }
If you try to use it it looks correct:
int* ptr = wrong(); std::cout << *ptr << std::endl;
That will print
10
, but the memory where data was defined has been freed, and is no longer in control of the program. Meaning that if something else allocated that memory they can control what my program does.Consider that on that example above later in the program we do:
user.access_level = *ptr;
If someone manages to get control of that memory between when we freed it and we used it they can make the access_level of the user be whatever they want.
This is a problem with C/C++ allowing you to access memory that has been freed, which is why C/C++ programmers need to be extra careful.
Thank you, that is very clear.
The problem is bad programmers. You can write good C code but it takes more effort and security checking. You also can write vulnerable and sloppy Rust code.
I don’t think it’s realistic to expect a rewrite of code that works. Maybe over time we can start implementing pieces in safer languages.
I admit C++ ain’t safe, but wonder if there’s an alternative to going Rust. Don’t get me wrong, I love the language. But Rust is a beast on its own. I read here that game devs generally can’t adapt Rust because the language forces frequent refactoring, which doesn’t fit the business speed of game development.
I don’t care for Rust because I like writing unsafe code. It’s fun. However, I would value the assurances it provides using software written in Rust.
Is there a way to jailbreak an Android phone using this exploit?
You could just unlock the bootloader
Assuming the bootloader is unlockable
You could just buy an android phone that encourages this. All Pixels, for example.
deleted by creator
No, but buy a different one when this one breaks is.
deleted by creator
It helps them long term
Of course it helps them
+1 for Pixels but -1 for Google’s “support”. You’ll never talk to a human with them. I love GrapheneOS on my Pixel though, and they’re really the only phones you can install it on cause you can re-lock the bootloader on it after installing. CalyxOS (fork of Graphene with slightly less sandboxing) does support FairPhone 4&5 and a few Motorola phones though.
Is this even new?
I thought this already circulated a few months back.
Even Debian stable has already patched it.
Debian is actually one of the fastest patchers
RHEL on the other hand
Security patches do the opposite of break stuff
This is the best summary I could come up with:
It’s the result of a use-after-free error, a class of vulnerability that occurs in software written in the C and C++ languages when a process continues to access a memory location after it has been freed or deallocated.
At the time this Ars post went live, there were no known details about the active exploitation.
A deep-dive write-up of the vulnerability reveals that these exploits provide “a very powerful double-free primitive when the correct code paths are hit.” Double-free vulnerabilities are a subclass of use-after-free errors that occur when the free() function for freeing memory is called more than once for the same location.
The write-up lists multiple ways to exploit the vulnerability, along with code for doing so.
The double-free error is the result of a failure to achieve input sanitization in netfilter verdicts when nf_tables and unprivileged user namespaces are enabled.
Some of the most effective exploitation techniques allow for arbitrary code execution in the kernel and can be fashioned to drop a universal root shell.
The original article contains 351 words, the summary contains 168 words. Saved 52%. I’m a bot and I’m open source!