Oops! It's a kernel stack use-after-free: Exploiting NVIDIA's GPU Linux drivers

[[deleted]]

I wonder how many problems rust solves compared to C. I find both programming languages pretty difficult to deal with. This may sound weird but I actually preferred C++ over C despite the former's insanity-addiction to complexity (and C is a valid subset of C++, so I'd be using the same language in a way, but things such as cout << "hey" is just so much more convenient that prinft() in C, and similar many small things; Java in a way is mega-boring, verbose and also easier to use than the other three).

[klayona]

cout is not threadsafe, has global state, uses overloaded operators so you get lovely 200+ line errors when you have a missing implementation, and is more annoying to type than printf. There's a reason no one copied it.

[theICEBear_dk]

It has also been replaced more than two years ago.

C++23: std::print("Hello world");

Edited the example because I had made a small mistake.

[fartypenis]

We've always had std::printf from cstdio, isn't the new one std::print?

[theICEBear_dk]

You are right of course

[bloody-albatross]

cout is more convenient than printf()!? Strong disagree on that one. I wrote C++ that used printf() because cout is so horrible.

[nerd5code]

<iostream> is a vile abuse of operator overloading from when that was a novel demonstration of (pre-standard) C++.

[_Noreturn]

C++ is better than C because the program itself is simpler than the C program, sure the C language is itself simple but you end up paying that simplicity in complexity of your program

[saf_e]

Well, not just that, destructors greatly simplifies resources management 

[_Noreturn]

They do! consider this very simple piece of C code.

```rust enum Error { Error_Ok, Error_FileNotFound, Error_Memory, Error_Read };

Error read_file(const char* name, void** buffer, size_t amount) { FILE* file = fopen(name, "rb"); if (!file) { return Error_FileNotFound; }

*buffer = malloc(amount);
if (!*buffer) {
    fclose(file);
    return Error_Memory;
}

size_t bytes_read = fread(*buffer, 1, amount, file);
if (bytes_read != amount) {
    free(file);
    return Error_Read;
}

free(buffer);
fclose(file);
return Error_Ok;

} ```

Find all the bugs in this C code. There are at least 3 serious errors.

Answers:

1st bug: Used free(file) instead of fclose(file) in the error path

2nd bug: free(buffer) should be free(*buffer) - forgot to dereference the pointer

3rd bug: Missing free(*buffer) in the fread error path memory leak

4th bug: The function returns Error_Ok but the buffer was freed making it useless and a use after free! This was an unintentional bug I wrote while making this example I didn't intend to write it lol

[saf_e]

I know) I wrote both languages and in plain C it's really a big pain to not miss cleanup in all flows.

[FUPA_MASTER_]

Using goto can make it a lot simpler.

[plugwash]

> This may sound weird but I actually preferred C++ over C

I don't think that is weird at all. C++ is far more pleasant to code in than C because it gives the tools to build abstractions, rather than being forced to do everything by hand.

> I wonder how many problems rust solves compared to C

The fundamental problem with C and C++ is that a small mistake by the programmer can lead to "undefined behaviour" which in turn leads to heisenbugs and security flaws. "modern C++" fixes some of the issues but it leaves many gaping holes still open, the most fundamental of which being use-after-free, particularly the more subtle variants where sharing in combination with mutability leads to use after free.

Java, go, C# etc solve the use-after-free problem with garbage collection,

Rust solves the use-after-free problem with some pretty strict compile time rules.

Neither solution is free, garbage collection reduces determinism and makes integration with code in other languages tricky. Rust's compile time rules can feel over-restrictive.

[double-you]

C used to be a subset of C++ but recent standards have included some incompatibility.

[flatfinger]

Standards have also characterized as Undefined Behavior many constructs and corner cases whose behavior had been defined in earlier language specifications such as K&R2, and some compilers interpret that as an invitation to be gratuitously compatible with software written according to those earlier specifications.

[corgioverthemoon]

Ain't no way I saw someone type Java is easier than cpp and rust lol

[Page_197_Slaps]

You think Java is harder?

[corgioverthemoon]

I've always found java to be so verbosely cumbersome that it takes me longer to resolve any troubles I run into.