Let's assume an insecure communication channel.

Alice makes a public key (we assume is PGP, but any asymmetric crypto could be used unless it doesn't have fingerprints for checking) and sends it to Bob.

Then, Alice sends to Bob a photo of her key's fingerprint so Bob can check if a MITM attack occurred replacing the key.

Obviously an attacker could replace the photo too, with the fingerprint of the eavesdropper's key, but, how likely would this happen? What about time? The eavesdropper doesn't have all the time to do it, and we assume that Bob immediately receives it, so is it safe to assume that the photo of Alice's key's fingerprint is good?

The same could be applied with hash checking, I'm I correct?

And what if Alice signs the photo with her handwriting before sending it? Let's say with a photo editor? I think this would make the eavesdropper taking more time, and Bob would surely know that something is wrong if the photo takes too long to arrive.

  • How likely is it that someone would be prepared for this completely novel approach and situation? That's not answerable. It's a novel situation ... Same for trying to figure out how long it would take. If they are prepared for it, it wouldn't take time.
    – schroeder
    Jun 30, 2020 at 11:07

3 Answers 3


Alice wants to send the same public key twice, and Bob has to manually check that they match? Not sure about the practicality of this. If this was a regular thing, and I was Bob, I'd put the photo through an OCR* script to automatically do the checking. And if I was the hacker I'd write a script to automatically alter the public key and generate a corresponding photo. Overall, I think this is not secure.

* OCR: optical character recognition


Bob and Alice should use a separate, secure channel to exchange their keys. A photo sent over the same insecure channel doesn't provide that. We can't say how likely anything is, but as with all security through obscurity, assume the worst. The authenticity of the key is as trustworthy as the channel used to transmit it.

The secure channel for changing the public keys doesn't have to be encrypted i.e. provide privacy, but it has to provide some authentication and data integrity. Alice could for example host the key on a HTTPS website that only she can control or send it via DKIM signed email.

If there is no such channel between Alice and Bob at all, the key could be split into pieces transmitted over separate, independent channels. This doesn't guarantee it's really Alice who's sending the key, but reduces the risk, as it's harder to get MitM position on several independent channels at the same time. If only one piece of the key is tampered, a MitM attacker cannot decrypt the message, although neither can Alice.


Remember than the characters in those "Alice and Bob" stories aren't people, they are computers. And all the things they are doing in those stories is done automatically by software.

It isn't difficult for the software running on Eve to encode a new image file with the text representation of a different public key. There are software libraries for turning text into images, and they are fast enough to do that within milliseconds. So it would be impossible for the software running on the computer Bob to tell if the key was generated by the software running on Alice or the software running on Eve.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .