Things to note about this:

1. We are now using two separate co-processors! In this example, Bob is simply using his co-processor as a

verification engine. This could be accomplished by any computer that can compute ECC signature

verification. But it's really quite nice to offload this calculation to a co-processor, and it will perform the

calculations very fast.

2. Alice signed her message with her private key and she gave her public key to Bob. Hopefully the private vs

public thing is starting to sink in.

3. Bob used an external public key (Alice's) to verify the authenticity of Alice. He could potentially name this

anything he wants. And he could store lots of them, if he wanted to be able to verify messages from other

senders.

4. Alice will most likely make her public key truly public and let everyone know about it. Once everyone has it,

then she can send authenticated messages to anyone she likes, and they will truly know that it came from

Alice.

5. It does not have to be a one-way street. The example could easily be reversed and Bob could give Alice his

public key. When they both have shared their public key with the other, they can both send and verify.

The Code

As mentioned above, this example has two sketches. The purpose of splitting it up allows us to build upon the first

three examples, and communicate securely between two completely separate systems.

Let's take a closer look at the important stuff within Alice's sketch: