Question

I am tasked with implementing a dongle-based copy protection scheme for an application. I realize that no matter what I do, someone will crack it, but I want to at least make it a little more difficult than an if-statement checking whether a dongle is present.

My approach is to encrypt critical data that the application needs for proper execution. During runtime, the decryption key is retrieved from the dongle (our chosen model has some suitable API functions for that), the data is decrypted and the application is happy.

Of course, a determined attacker can intercept that decryption key and also get ahold of the decrypted data. That’s ok. But what should be hard is to substitute their own data. So I’m looking for an encryption scheme where knowing the decryption key doesn’t enable someone to encrypt their own data.

That’s obviously asymmetric encryption. But for every such algorithm I found so far, the encryption (or public) key can be generated from the decryption (or private) key, which is exactly what I’m trying to avoid.

Note: simply signing the data won’t help much, since (unless I’m totally misunderstanding such signatures) verifying the signature will just be another if-statement, which is easily circumvented.

So… any ideas?

Answer 1

To answer my own question (somewhat), it is possible to do this with RSA, but most APIs (including the one of OpenSSL’s crypto library) need to be “tricked” into doing it. The reason you can generate the public key, given the private key, is that

1. It is common practive for implementations of RSA to save p and q (those big prime numbers) in the private key data structure.

2. Since the public key (which consists of the modulus N and some exponent e) is public anyway, there’s (usually) no point in choosing an obscure e. Thus, there are a handful of standard values that are used commonly, like 3 or 65537. So even if p and q are unknown, you might be able to “guess” the public exponent.

However, RSA is symmetrical in the sense that anything you encrypt with the public key can be decrypted with the private key and vice versa. So what I’ve done (I’m a monster) is to let the crypto library generate an RSA key. You can choose your own public exponent there, which will later be used to decrypt (contrary to the normal way). Then, I switch around the public and private exponent in the key data structure.

Some tips for anyone trying to do something similar with the crypto library:

1. In the RSA data structure, clear out everything but n and e / d, depending on whether you want to encrypt or decrypt with that particular key.

2. Turn off blinding with RSA_blind_off. It requires the encryption exponent even when decrypting, which is not what we want. Note that this might open you up to some attacks.

If someone needs more help, leave a comment and I’ll edit this post with more information.