• treadful@lemmy.zip
    link
    fedilink
    English
    arrow-up
    124
    ·
    2 months ago

    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.

  • The Doctor@beehaw.org
    link
    fedilink
    English
    arrow-up
    74
    ·
    2 months ago

    Outfits that haven’t installed patches since February are getting popped in May by a vuln that was published in January.

    • Venia Silente@lemm.ee
      link
      fedilink
      English
      arrow-up
      79
      arrow-down
      13
      ·
      2 months ago

      Oh, we heard, Rust is the greatest invention since sliced bread. We heard it already. Like 65534 times.

      • urska@lemmy.ca
        link
        fedilink
        arrow-up
        33
        arrow-down
        7
        ·
        2 months ago

        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.
          • urska@lemmy.ca
            link
            fedilink
            arrow-up
            5
            ·
            edit-2
            2 months ago

            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.

              • urska@lemmy.ca
                link
                fedilink
                arrow-up
                2
                ·
                1 month ago

                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

        • imgcat@lemmy.ml
          link
          fedilink
          arrow-up
          4
          arrow-down
          5
          ·
          2 months ago

          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!

        • corsicanguppy@lemmy.ca
          link
          fedilink
          arrow-up
          5
          arrow-down
          9
          ·
          2 months ago
          • 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.

          • urska@lemmy.ca
            link
            fedilink
            arrow-up
            4
            ·
            2 months ago

            Well no, those companies deal with really important subjects. Airplanes, car safety, chemotherapy machines, missiles, etc. Have a good day

      • The Doctor@beehaw.org
        link
        fedilink
        English
        arrow-up
        18
        ·
        2 months ago

        I wonder how many folks are just refusing to use Rust to spite the Rust Evangelism Strike Team.

            • delirious_owl@discuss.online
              link
              fedilink
              arrow-up
              5
              ·
              2 months ago

              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.

              • uhN0id@programming.dev
                link
                fedilink
                arrow-up
                3
                ·
                2 months ago

                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!

    • corsicanguppy@lemmy.ca
      link
      fedilink
      arrow-up
      32
      arrow-down
      1
      ·
      2 months ago

      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.

    • the_doktor@lemmy.zip
      link
      fedilink
      arrow-up
      21
      arrow-down
      9
      ·
      2 months ago

      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.

      • ProgrammingSocks@pawb.social
        link
        fedilink
        arrow-up
        11
        arrow-down
        1
        ·
        2 months ago

        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.

        • pathief@lemmy.world
          link
          fedilink
          arrow-up
          7
          ·
          2 months ago

          Even good developers make mistakes. It’s really nice to catch these mistakes at compile time.

      • Miaou@jlai.lu
        link
        fedilink
        arrow-up
        8
        arrow-down
        4
        ·
        2 months ago

        But it is, do you not understand what rust brings compared to these two languages ?

        • the_doktor@lemmy.zip
          link
          fedilink
          arrow-up
          1
          arrow-down
          5
          ·
          2 months ago

          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.

          • uhN0id@programming.dev
            link
            fedilink
            arrow-up
            5
            ·
            edit-2
            2 months ago

            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

          • Kazumara
            link
            fedilink
            arrow-up
            2
            ·
            edit-2
            2 months ago

            A language for noobs

            That assertion surprises me; I find C easier to use than Rust.

    • Possibly linux@lemmy.zip
      link
      fedilink
      English
      arrow-up
      5
      ·
      2 months ago

      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.

    • DacoTaco@lemmy.world
      link
      fedilink
      arrow-up
      7
      arrow-down
      2
      ·
      2 months ago

      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

      • sleep_deprived@lemmy.world
        link
        fedilink
        arrow-up
        32
        arrow-down
        2
        ·
        2 months ago

        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 using drop() 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 is droped, 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!

        • DacoTaco@lemmy.world
          link
          fedilink
          arrow-up
          2
          arrow-down
          1
          ·
          2 months ago

          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?

          • mhague@lemmy.world
            link
            fedilink
            arrow-up
            5
            ·
            edit-2
            2 months ago

            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.

            • DacoTaco@lemmy.world
              link
              fedilink
              arrow-up
              1
              ·
              edit-2
              1 month ago

              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 ]

              • mhague@lemmy.world
                link
                fedilink
                arrow-up
                1
                ·
                edit-2
                1 month ago

                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.

          • been_jamming@lemm.ee
            link
            fedilink
            arrow-up
            4
            arrow-down
            1
            ·
            2 months ago

            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.

          • ProgrammingSocks@pawb.social
            link
            fedilink
            arrow-up
            2
            ·
            edit-2
            2 months ago

            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.

            • DacoTaco@lemmy.world
              link
              fedilink
              arrow-up
              1
              ·
              1 month ago

              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.

              • ProgrammingSocks@pawb.social
                link
                fedilink
                arrow-up
                1
                ·
                edit-2
                1 month ago

                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.

        • paysrenttobirds@sh.itjust.works
          link
          fedilink
          arrow-up
          1
          arrow-down
          2
          ·
          2 months ago

          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?

          • Feyd@programming.dev
            link
            fedilink
            arrow-up
            10
            ·
            2 months ago

            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

            • paysrenttobirds@sh.itjust.works
              link
              fedilink
              arrow-up
              2
              ·
              2 months ago

              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.

          • Nibodhika@lemmy.world
            link
            fedilink
            arrow-up
            9
            ·
            2 months ago

            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.

    • henfredemars@infosec.pub
      link
      fedilink
      English
      arrow-up
      4
      arrow-down
      3
      ·
      2 months ago

      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.

      • eveninghere@beehaw.org
        link
        fedilink
        arrow-up
        3
        ·
        2 months ago

        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.

        • henfredemars@infosec.pub
          link
          fedilink
          English
          arrow-up
          1
          ·
          2 months ago

          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.

  • AutoTL;DR@lemmings.worldB
    link
    fedilink
    English
    arrow-up
    13
    ·
    2 months ago

    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!

    • Possibly linux@lemmy.zip
      link
      fedilink
      English
      arrow-up
      2
      ·
      2 months ago

      Until it doesn’t. The problem will rolling releases is that a lot of security issues are introduced quickly. Debian has far fewer security problems than Arch.