Consider something like the XCF file format used by a program like GIMP including all kinds of fancy structured data. People are certainly exchanging these files. SQLite would be a substantially safer base to build on than the current GIMP implementation. I'm quite sure of that.
Conversation
Or heck, .doc or .psd, which are basically just memcpy’d internal structures of Word and Photoshop respectively.
1
That's basically XCF too.
github.com/GNOME/gimp/blo
They're collaborating with the Krita developers to make en.wikipedia.org/wiki/OpenRaster as a replacement. It's probably going to be even more complex though since they're going to want to add more capabilities.
1
2
The solution to the problem cannot be not making this kind of software, or somehow getting users not to exchange media files, image editing files, word processor documents, etc. Really just parse the file format in a memory safe language without dynamic code execution.
1
5
And that memory safe language can certainly be a subset of C with annotations / rules that make it memory safe. No problem with that, I just don't think it's a very useful/practical thing to do personally since I'd rather use a nicer language if it has to be from scratch anyway.
1
1
We know how to write software with decent security and these kinds of capabilities. It's not a mystery. We choose to use software architectures and languages making it unrealistic to provide decent security. Even if you claim that it's due to programmer incompetence, not tools...
1
2
3
... then clearly there are near 0% competent C programmers. The whole point of safer tooling is that humans aren't being trusted to never make a mistake or miss something. It's extremely hard to right completely correct software and those bugs should not be remotely exploitable.
2
2
5
The tools can't allow assorted little mistakes which are certainly going to happen to cause code execution vulnerabilities. It just isn't a viable way to build a secure computing ecosystem still capable of doing the same kinds of things, like loading up a GIMP / Krita project.
1
1
Should definitely work to avoid bugs as much as possible. A huge part of is eliminating bug classes with better tools. It's also important to prevent the remaining bug classes from being exploitable in ways like gaining code execution and we know how to get 99.9% there.
1
There's a big distinction between weak warnings / static analysis and doing it properly. For example, GCC / Clang will warn for things like possibly uninitialized variables. However, they don't implement a system for guaranteeing that C code has no uninitialized variable use.
1
1
It's easy to implement that. It requires the code to actually be written with it in mind. The compiler simply enforces that every code path must initialize the variable before it's used (also applies to parts of structures / arrays). They can define how clever the analysis is.
It actually has to be clearly defined. If the standard set of rules isn't able to demonstrate that something is initialized before use, you have to initialize it, or if it's perf critical and it can be demonstrated as correct to humans, you could mark it unsafe + use intrinsic.
1
Now, you do this for all the other safety issues, which requires coming up with more systems for enforcing safety. You end up with C code that is still just as portable, but with the rules and annotations is actually verifiable as memory safe. It essentially reinvents Rust.
1
Show replies