# Delivering data securely when the data source is the key maker

Let's say we have the following:

• Bob needs to send data securely to Alice.
• Only Bob and Alice are allowed to read/see that data.
• Alice is not able/allowed to create keys.
• Alice can use any number or type of keys to decrypt data.
• Bob can create and share any number or types of keys
• Bob and Alice can have an initial secure exchange of information.

How would Bob and Alice use PGP or alternative public-key cryptography system to meet their communication needs?

• Are we to assume all exchanges between Alice and Bob are public and open to interception or is there an initial moment of privacy (e.g. Alice and Bob are co-located in a secure room without listening devices where Bob can give Alice a private key)? Commented Nov 6, 2018 at 16:49
• Initial moment of privacy is fine, but would be curious in the other scenario as well. Thanks @DarkMatter Commented Nov 6, 2018 at 16:52
• Merkle’s original scheme solves exactly this problem. Commented Nov 7, 2018 at 6:54
• Thanks @Wildcard -- Can you please elaborate? Commented Nov 7, 2018 at 15:16

Per the stipulation that Alice and Bob may conduct a private initial exchange in person (or through some other secure channel they have been previously using) Bob simply generates a separate Private-Public key pair for each of them. He can then hand Alice her private key and they can proceed to do normal public key cryptography from then on as if Alice had constructed her own Private-Public key pair.

Merkle's initial scheme for "Secure Communication over Insecure Channels," the first approximation of public key cryptography, could solve exactly this problem without even the need for the initial secure exchange of information.

Here is how Bruce Schneier summarized the scheme in his book "Applied Cryptography":

Merkle's technique was based on “puzzles” that were easier to solve for the sender and receiver than for an eavesdropper. Here's how Alice sends an encrypted message to Bob without first having to exchange a key with him.

1. Bob generates 2^20, or about a million, messages of the form: “This is puzzle number x. This is the secret key number y,” where x is a random number and y is a random secret key. Both x and y are different for each message. Using a symmetric algorithm, he encrypts each message with a different 20-bit key and sends them all to Alice.
2. Alice chooses one message at random and performs a brute-force attack to recover the plaintext. This is a large, but not impossible, amount of work.
3. Alice encrypts her secret message with the key she recovered and some symmetric algorithm, and sends it to Bob along with x.
4. Bob knows which secret key y he encrypts in message x, so he can decrypt the message.