Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
I have gone through ken thompson's compiler hack paper, can't we just go through the complier's source code and check for any backdoor, what was the article's point?
https://www.archive.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf
Can we be sure that there are no backdoor's if we check the latest language's source code like python or php?
No. The source code is not usable since it cannot be executed, only machine code can be executed. And to transform it into a binary you need a compiler. But you have no assurance that the compiler you are using to make that binary does, in fact, make a faithful job of the transformation.
To guard against the Thompson hack you have to bootstrap your own compiler, starting with a small program that you wrote yourself and progressively making it more powerful while maintaining accountability. The point of Thompson's paper is that proving a compiler is trustworthy is as much effort as creating it in the first place.
The point is that there is no back door in your source code because the compiler that you use to compile that code has been tweaked to add it into the binary it produces any time it detects that it is compiling a compiler or compiling login. To catch this you need to be looking at the object code not the source (And assuming that your tools for looking at object code have not themselves been compiled with a compiler that adds code to hide things from you!).
Once a compiler has been compromised, nothing it compiles can be trusted, including compilers that it compiles (even if their own source is clean) because the compromised compiler compiling the clean compiler can be making the clean compiler compromised while it is compiling the compiler....
If you had access to the source code for the full tool chain, viewing that source would indeed be sufficient. The thing is, that is a nigh impossible task decades after the fact. Note that decades after the fact refers not to today, but when the article was written. Assemblers were already a thing, and an assembler is nothing more than a simple compiler.
If you want to be sure that your compiler hasn’t been hacked, you need to write it in binary. And you need to do that for your entire tool chain — perhaps it wasn’t the compiler that was hacked, but the disk driver or editor. Perhaps it was the file copier. At some point you either have to trust your tools, or start from scratch with bare metal. Today’s CPU’s are sophisticated enough that you could hide such a hack in them without difficulty.
Think of the recent Intel chip vulnerability (meltdown, spectre) or the alleged Bloomberg China chip attack.
