Why not rust for security? posted September 2020
I read a Why Not Rust? article the other day that was quite good but dismissed the most important reason to use a language to me: security. After having worked on a Rust codebase for almost two years now, I thought I would chime in, even though I'll preface the post by saying that Rust is totally the right language you should use if you know what you're doing and are aiming for performance and security, yet I still have some pain points that will make me recommend Golang over Rust sometimes. Keep in mind that I have also spent my whole career looking for bugs in applications written in dozens of different languages, so my post might be highly controversial but it has to be looked from these lenses.
Shallow standard library
Not only this, but if you're a newcomer to Rust, how do you even pick the right library? I can't even fathom how anyone writing a project in Rust gets to pick a good library for generating cryptographic random numbers, or for doing any type of crypto like encrypting or hashing, or for decoding hex strings, or for decoding JSON, or for using TCP, or even for using TLS! On the other hand Golang has all of that in its standard library, that means that when you use Golang you:
- can't pick the wrong algorithm (e.g. DES instead of AES)
- can't pick a bad implementation (the standard library is known to be high quality)
- can't pick a dependency that ends up importing plenty of other third-party dependencies (unlike Rust, the Golang standard library never imports third-party libraries)
- don't have to worry about version updates (you're just updating your version of Golang instead of the versions of many dependencies)
- don't have to worry about transitive dependencies that you can't update (again, Golang standard library doesn't rely on third-party dependencies)
For Libra we've used a number of techniques in order to reduce the number of third-party dependencies we use. This included figuring out when we used different dependencies that did the same thing, or figuring out what obscure dependencies we should avoid, we even re-wrote a large number of dependencies to avoid dependencies that ended up exploding the number of transitive third-party dependencies we imported. One useful tool we used for some of that is dephell which is built on top of guppy.
Rustfmt is imperfect
rustfmt is great, but
rustfmt sucks. Why does it suck? Two reasons:
- it's not mandatory
- it's configurable
On the other hand, Golang's compiler is very strict and will yell at you early on if you have dead code, unused dependencies, badly formatted code, and so on. It doesn't replace
gofmt, but it's much more opinionated and is much more effective at making Golang's codebases more readable (especially if they forget to run
gofmt). In addition, if you do use
gofmt, you can't configure it! This is very apparent when you read Golang code, it always looks the same! And it is pretty fucking fantastic if you ask me, because not only Golang is easy to learn, but you can quickly get used to any Golang codebase due to the consistent formatting of the language.
Too many ways to do things
Rust has a somewhat different syntax from other languages of its genre, and you sometimes see things that you might not be used to see (statement as expression, match statements, lifetimes, etc.) I couldn't care less about these, these are things you can learn, and you end up getting used to them. What I can't get used to is the sheer number of ways to do something. There are so many keywords in Rust, and there's so many ways to end up bike shedding on the best way to write the exact same statement, that I consider it a waste of time. It's a waste of time for the developers, but also for the reviewers who will often run into keywords that they've never seen before. For example, there are too many ways to panic on purpose:
assert!(), and so on.
Generics and macros
Rust is too expressive. This is of course great for some use-cases, but holy shit if a developer wants to be too clever, they can create the most unintelligible codebase that you'll ever seen. This is probably the most controversial point, but security is not just safety, it's also readability. As we say "complexity is the enemy of security", and generics undeniably add complexity. This is of course up to the developers to abuse them, but the great thing about Golang is that there aren't many things to abuse, codebases are often straight forward and you can quickly understand what is happening.
Ok, you're being unreasonable David
Sure, I'm omitting a lot of good Rust things in here, but this is a post about the security downsides of Rust, not the upsides, which let's be clear still make Rust the perfect language to write a sensitive application in. You just need to know what you're doing. This also means that Rust has a lot of room to mature, while generics are here to stay, there is no excuse to keep slipping the shallow stdlib under the rug.
So Go with fit better for Libra from a security point of view?
David isn't necessarily advocating for using Go over Rust in a project like Libra, he's just highlighting some cases where Rust *could* become an issue. To preface this, I like both Rust and Go.
First off, I would like to see just where the Rust std library imports third-party code.
Also you might say that some of the "cons" of Rust listed here are actually benefits of the language or just not necessarily cons. For one, "rustfmt is configurable" isn't a real con; it's just a personal preference. Some people never want to see anything different and some people want to configure things. Yet, in my work with Rust, 99% of the projects either have no rustfmt preferences or they are very minor configs, so this isn't actually an issue at all.
Another thing to mention is that unwrap(), expect(), and the list of macros in the article don't all do the same thing, so this isn't really a valid point either. The argument here is that, since there are more keywords for panicking, the code is more unreadable if you don't know these words. A counterargument (besides the fact that unwrap and expect are different) would be that the different ways of manually panicking enhance readability by providing context to the panic.
As for generics and macros in Rust, I won't even go into `...`, nil, Go generation, or the readability of manipulating slices in Go...
Very interesting article. Thanks.
For dependencies checkout out cargo-crev. It gives you assessment of your dependencies based on web of trust and code reviews.
@Samuel One example is that the Rust standard library's HashMap implementation uses the third party crate hashbrown
Very interesting read David! I very much appreciated your perspective on this topic, and even though it makes common sense: "complexity is the enemy of security" is a very insightful statement which I will leverage personally in the future!
Keep up the great work, you do make a difference!
leave a comment...