Running the "Reflections on Trusting Trust" Compiler

https://research.swtch.com/nih

by rsc • 3 years ago

287 67 3 years ago

research.swtch.com

earthboundkid• 3 years ago

Usually rsc’s blog posts are intimations of what he’s going to propose next for Go. Um, er, oh boy.

mseepgood• 3 years ago

It is indirectly about the new reproducible Go toolchain builds introduced with Go 1.21. https://go.dev/blog/rebuild

kunley2• 3 years ago

Haha, good one ;)

dolmen2• 3 years ago

In this case, I think it is more about an Easter egg in the Go compiler.

I'm expecting we will finally discover a backdoor propagated since at least Go 1.4.

saagarjha• 3 years ago

There’s of course a couple of notes on combating this attack: most compilers of today don’t actually produce exactly the same code if you run them twice. In broad strokes they do but often they’ll have randomness creep in, such as different build hashes or iteration order of associative containers. To truly get a bit-for-bit identical output you may need to do some extra work, or perhaps run yet another step in a controlled environment to protect against this.

Second, and more importantly, many people carry a copy of a trusted compiler around, though it’s rarely mention in attacks like these: their head. In a pinch people can do spot checks to verify codegen to see whether it looks correct, unless the backdoor is incredibly subtle. But experience shows us that the more complex and hidden a backdoor is the more likely it is to break when subjected to unfamiliar examination.

wyldfire2• 3 years ago

clang+llvm releases do a three stage build and compare the output of the third stage with the second. This is fairly effective at rooting out many sources of indeterminate behavior.

In broad strokes they do but often they’ll have randomness creep in, such as different build hashes or iteration order of associative containers.

In order to find defects related to codegen being altered by incidental ordering of objects in containers, a build option called LLVM_ENABLE_REVERSE_ITERATION was created. Builders periodically run with this mode to verify that the regression test suite still passes when containers iterate in reverse.

That said, it's true that there are probably remaining sources of variation among builds. There is a significant effort [1] to find these and avoid them.

[1] https://reproducible-builds.org/

vlovich1232• 3 years ago

Not all containers right? Just unordered containers. It’s a bit weird of a strategy though - most other applications use a random seed for unordered hash tables.

userbinator2• 3 years ago

most compilers of today don’t actually produce exactly the same code if you run them twice.

Timestamps are one of the biggest offenders, but this is also why reproducible builds are important. Nondeterministic codegen is just scary.

Second, and more importantly, many people carry a copy of a trusted compiler around, though it’s rarely mention in attacks like these: their head.

This is also why I'm against inefficient bloated software in general: the bigger a binary is, the easier it is to hide something in it.

Along the same lines, a third idea I have for defending against such attacks is better decompilers --- ideally, repeatedly decompiling and recompiling should converge to a fixed point, whereas a backdoor in a compiler should cause it to decompile into source that's noticeably divergent.

charcircuit6• 3 years ago

Timestamps are one of the biggest offenders
Nondeterministic codegen is just scary.

Why not focus on deterministic codegen only? Caring about some metadata changing does not seem to be as useful from a security perspective.

chii2• 3 years ago

decompilers ... converge to a fixed point

but why would you assume that the decompiler is not backdoored? It would know to remove the backdoor code, so the fixpoint is not going to show anything.

scythe2• 3 years ago

Mike Pall somewhat famously wrote a Lua interpreter in assembler. Assuming that you can write a compiler for your language in Lua, you don't really have to trust trust, but you do have to trust Mike Pall. I'm not aware of any other raw assembly implementations of modern programming languages, but I suspect there are other examples. The overall scheme (^,~) could probably be replicated by a sufficiently dedicated team if there was interest.

Not exactly easy, but probably easier than a decompiler that produces human-equivalent source code.

yjftsjthsd-h• 3 years ago

most compilers of today don’t actually produce exactly the same code if you run them twice.

By default, but https://reproducible-builds.org/ has made excellent headway on allowing that to be fixed if you care.

yegle• 3 years ago

What a coincidence, I was reading the GNU Mes project's doc today that's very relevant: https://www.gnu.org/software/mes/manual/mes.html

userbinator2• 3 years ago

I thought of the term "bootstrap pilgrimage" years ago to concisely refer to such projects --- both to highlight the journey of learning they give, and to refer to the fact that not everyone may have the time nor skill to embark on one.

shepherdjerred2• 3 years ago

I've always struggled to find a succinct way to describe the benefits of installing Arch Linux. "bootstrap pilgrimage" is the perfect term!

thaliaarchi3• 3 years ago

I like that term. I've tried a couple of bootstrap pilgrimages.

For a job, we needed Go on FreeBSD 8, which entailed a local patch to revert pipe2 to pipe in Go, and building from source. That was my first bootstrap. Go, as Russ mentions, is easy to bootstrap, and I've done it a couple of other times.

I've tried to bootstrap Rust, from its old compiler written in OCaml, but that one is trickier. It has not been maintained like Go's bootstrap compiler and the bootstrap chain has long since been broken. Furthermore, rustc is only guaranteed to be able to be buildable with the previous release. As far as I can tell, no one has built rustboot in many years. I like doing software archaeology, so I'll probably try again with that project sometime.

mrustc takes another approach, closer to the aforementioned GNU Mes, in that it's a reimplementation of Rust, intended for bootstrapping rustc. https://github.com/thepowersgang/mrustc

pabs3• 3 years ago

See also the Bootstrappable Builds project, especially their stage0 projects:

https://bootstrappable.org/ https://github.com/oriansj/stage0 https://github.com/oriansj/stage0-posix/

legobmw99• 3 years ago

Reminds me of https://elephly.net/posts/2017-01-09-bootstrapping-haskell-p...

The difficulty of bootstrapping GHC

kunley2• 3 years ago

I love such a trivia like how Russ named the article link after Ken's original naming..

Obscurity4340• 3 years ago

Trusting Russ

NelsonMinar• 3 years ago

What a fantastic analysis. I've loved the Trusting Trust paper for decades now, it's so short and sweet and mind-blowing. But I honestly assumed it was a kind of thought experiment, not something Thompson actually created. Amazing to see the actual code and also learn how it sort of got into the wild but didn't quite pervade. (At least, we don't think so.)

matheusmoreira• 3 years ago

I never expected this to actually exist either. I thought it was just some hypothetical thought experiment. The implications are astounding.

Code already decides the future of nations. My country uses voting machines which run software. People keep asking for the source code even though it would prove nothing...

unhammer• 3 years ago

Wow, the attack was implemented nearly ten years before the lecture, maybe right after reading https://seclab.cs.ucdavis.edu/projects/history/papers/karg74... about "the compiler trap door"?

dolmen2• 3 years ago

The more I read about Ken and Russ's admiration for Ken's work, the more I think there is an Easter egg in the Go compiler. It looks like Russ has long planted the seed for his own Turing Award.

From the article:

Today, however, the Go compiler does compile itelf, and that prompts the important question of why it should be trusted, especially when a backdoor is so easy to add. The answer is that we have never required that the compiler rebuild itself. Instead the compiler always builds from an earlier released version of the compiler. This way, anyone can reproduce the current binaries by starting with Go 1.4 (written in C), using Go 1.4 to compile Go 1.5, Go 1.5 to compile Go 1.6, and so on. There is no point in the cycle where the compiler is required to compile itself, so there is no place for a binary-only backdoor to hide.

I think that this paragraph gives just hints on where to look for:

* there is no "binary-only backdoor", so I'm expecting the backdoor to be available in the source distribution of Go.

* the backdoor is either in each release and/or is propagated from one release to the other

There is a feature of the Go compiler that I mistrust: //go:embed. I expect it could be a good vehicle to inject source code that isn't in the repository as a file. Especially as Russ himself is deeply involved in the design (see https://youtu.be/rmS-oWcBZaI?).

I also mistrust the vendored packages as a way to have backdoor code in the distribution. Normal Go programs are not allowed to import code from packages cmd/vendor/..., but what if the compiler was lifting that limit for himself?

Running the "Reflections on Trusting Trust" Compiler

Related Stories