- 1.1 Setting the Scene
- 1.2 Attack and Defense
- 1.3 Program Analysis
- 1.4 Code Obfuscation
- 1.5 Tamperproofing
- 1.6 Software Watermarking
- 1.7 Software Similarity
- 1.8 Hardware-Based Protection Techniques
- 1.9 Discussion
- 1.10 Notation
This chapter is from the book
This chapter is from the book
This chapter is from the book
1.8 Hardware-Based Protection Techniques
What makes it so difficult to design unassailable software protection techniques is that you never have any solid ground to stand on. The difference between software security and cryptography is that in cryptography you’re allowed to assume that there is one secret (the key) that your adversary will never be able to get his hands on. All security rises and falls with that assumption. In software protection, you can assume no such safe zone. The code of your obfuscated, watermarked, and tamperproofed program will always be available to the attacker for analysis because the attacker (who may also be your customer!) needs the code in order to run it.
Hardware-based protection techniques try to change that by providing a safe haven for data, code, and/or execution. The applications are the same as you’ve already seen: to protect the code from reverse engineering, to prevent the code from being tampered with, and to prevent illegal copying of the code. The difference is that now you’ve got one piece of hardware whose integrity you can trust and on which you can build protection schemes.
1.8.1 Distribution with Physical Token
The root cause of software piracy is that digital objects are trivial to clone. Cloning is not unheard of in the physical world, of course: To see that, just visit one of the many clothing and antique markets in China where near-identical copies of name-brand clothing lines and replicas of ancient artifacts are sold at cut-rate prices. Still, physical cloning requires considerable skill and sophisticated tools, whereas cloning in the virtual world only requires the attacker to learn how to use his computer’s copy command.
Several software anti-piracy techniques are based on the idea that a program will refuse to run unless the user first shows possession of a physical object. Thus, you ship your program in two parts: the easily clonable binary code itself and a hard-to-clone physical object that’s required for the binary to execute. The physical object needs to somehow be connected to the computer so that the program can occasionally check to see that the user actually has possession of it:
)
For the physical object to be effective, you need to manufacture it in such a way that it’s difficult to clone without specialized and expensive tools. Two types of objects have been common: dongles and program distribution disks (floppy disks, CDs, and DVDs). Dongles are connected to a port on the computer, these days mostly the USB port. The CD containing the application must be inserted into the computer’s CD drive in order for it to run. Often, the CD is manufactured so that ordinary copying software and hardware won’t be able to make an identical copy.
This anti-piracy technique has fallen out of favor for all but the most expensive programs. There are many reasons. First, the technique has proven to be highly annoying to legitimate users who can’t make backup copies of their legally purchased program, who lose the use of a port or a CD drive, and who can no longer use the program if they misplace the physical object. Second, it’s also annoying to the manufacturer who loses revenue from making and distributing the CD or dongle, who needs to deal with users who misplace it, and who can no longer simply distribute the program over the Internet.
1.8.2 Tying the Program to the CPU
If every manufactured copy of a CPU has a unique identity, you can solve the piracy problem by distributing your program so that each copy is only executable by a CPU with a particular identity. In practice, this is typically done by including in each CPU the private part of a unique public key cryptography key-pair along with a decryption unit. Here, Doris encrypts her program with Axel’s public key and distributes the encrypted program to him:
)
As a result, even if Axel were to resell the program to his friends, their CPUs will have different private keys and won’t be able to run the program.
This scheme isn’t without its own problems. First, manufacturing the CPU becomes more complicated since every copy will have to contain a different key. One solution is to squirt the key into the CPU after manufacturing and then disable any further modifications. Second, selling shrink-wrapped programs becomes difficult since every distributed copy needs to be differently encrypted. This may not be much of a problem these days, when many programs are sold and downloaded over the Internet. Finally, what happens when the user upgrades to a new computer with a faster CPU? Since it will have a different private key, he will need new versions of all the encrypted programs he ever bought. This means there must be some way for him to convince the program manufacturer that he’s no longer using the old CPU and that they should issue him a version to run on his new one.
1.8.3 Ensuring Safe Execution Environment
In the scenarios we consider in this book, Doris assumes that Axel’s computer, on which her program is running, is an unsafe environment; it could contain hostile programs (such as debuggers, binary editors, emulators, and disk copiers) that Axel can use to pirate, tamper with, or reverse engineer her program.
There has been considerable effort to build protection systems that would instead assure Doris that Axel’s computer is trustworthy, and that she can safely allow him to run her program without fear of it being violated. This is difficult to do using only software: The code on Axel’s computer that checks to see if he’s running any unsafe programs could itself be hacked! The idea instead is to have one small trusted hardware unit on Axel’s computer that helps Doris collect a reliable list of software that he’s running:
)
The protocol starts with Axel asking Doris for a copy of her program P to run, to which Doris responds, “Not so fast, prove to me that I can trust you first!” Axel’s computer (with the help of the trusted hardware) then collects a list of all its security-sensitive software and firmware and sends it to Doris. She compares it to a list of software she trusts, and only when she’s convinced herself that Axel’s computer constitutes a safe environment for P does she send it to him.
We’ve omitted many details here that you’ll learn about in Chapter 11. But it shouldn’t be hard for you to spot right now some fundamental issues with this scheme. First, any user who wants to run Doris’ program has to have a computer that’s been fitted with extra hardware, and obviously this will come at a cost. Second, Doris has to maintain a whitelist of all versions of all programs that she trusts, or a blacklist of all versions of all programs that she doesn’t trust. Given the vast number of programs available to run on many different hardware platforms and operating system configurations, this is likely to be a huge logistic nightmare. Finally, an actual protocol needs to take into account any privacy issues. For example, a user may not want to reveal to every site he’s communicating with which software he’s running.
An additional issue that makes many people queasy is that this protocol would be very useful in a digital rights management scenario. P would be the DRM player and the protocol would assure Doris that Axel won’t be able crack it to get to the decrypted media. This, in turn, would give Doris the confidence to allow Axel to download encrypted media to play.
1.8.4 Encrypted Execution
The ultimate solution to the software protection problem is to encrypt the program. As long as the program remains encrypted, the adversary can’t easily tamper with it, and can’t learn anything about its internal algorithms, and pirating it makes no sense since it’s not executable. However, eventually you’ll want your user (and potential adversary) to run the program. This means they will need access to the decryption key, which will give them access to your program in cleartext, which means they can do with it what they want. Game over.
For cryptography to provide unassailable protection, the program must remain encrypted throughout its lifetime, until it’s safely within the CPU itself. The CPU contains the key with which the program is encrypted. The key must never escape the CPU capsule or the adversary will gain access to the cleartext program. Schematically, crypto-processors are organized roughly like this:
)
The program (and any sensitive data) is stored encrypted in RAM but decrypted on the CPU itself. An encryption/decryption unit sits between the RAM and any on-chip caches and decrypts incoming code and data and encrypts any outgoing data.
As you will see in Chapter 11, to get this to work without revealing any information, everything must be protected once it leaves the safe haven of the CPU. The sequence of addresses that appear on the address bus can reveal information unless they’re properly scrambled, the sequence of encrypted data values that appear on the data bus can reveal information if they don’t change on every store, and the adversary might even get away with tampering with the encrypted program unless you check on every read that nothing has changed.
All this extra machinery obviously comes at a price, namely, performance. For example, modern CPUs are designed to take advantage of the locality of reference that programs typically display. If addresses are scrambled to hide access patterns, then the advantages of caches and locality-improving code optimizations are nullified. There’s also the question of how you convince your ordinary users that they should “upgrade” to a slower crypto-processor only for the benefit of protecting your program from piracy and tampering by themselves. Even if it’s unlikely that they’ll make it into commodity PCs any time soon, crypto-processors have an important role to fill in financial systems such as ATMs.
1.8.5 Physical Barriers
Any software protection system that makes use of a crypto-processor assumes that the secret key hidden within the CPU, in fact, remains hidden. An adversary, of course, will try to violate that assumption! There have been many attacks devised against smartcards, for example, since they are used in pay-TV systems, as stored-value cards, and as tickets on mass-transit systems, and thus breaking their security can provide financial gains to the attacker.
Attacks against crypto-processors are either invasive or non-invasive. Invasive attacks, essentially, scrape off the top of the packaging to give direct physical access to the internal circuitry. This can then be probed to reveal secret data (such as keys) and algorithms encoded in hardware. A non-invasive attack doesn’t physically abuse the CPU but rather feeds it bogus code or data, or forces it to operate under adverse environmental conditions, all with the intention of coaxing it to give up its secrets. For example, popular non-invasive attacks include delivering power spikes or irregular clock signals to the processor, or subjecting it to radiation. This can make it execute in a way its designers didn’t intend and, possibly, force it to reveal secret code and data.
Crypto-processors include physical layers of protection to prevent these kinds of attacks:
)
For example, sensors will alert the CPU if the temperature, voltage, clock signal, or radiation level appears abnormal. If the CPU believes it’s under attack, it will destroy any private data (such as keys), shut down, or even self-destruct. To prevent invasive attacks, the processor will have layers of shielding that make it difficult to drill down to the internal circuitry. These shields can also have sensors that can alert the CPU that it’s being probed.
Unfortunately, adding physical barriers will affect cost as well as performance. The higher the clock frequency, the more heat the CPU dissipates, and the thicker the layers of protection, the harder it will be for the processor to get rid of this excess heat! As a result, processors with thick physical protection barriers will have to be clocked at a lower frequency than equivalent unprotected processors.