########################################
## HTTPS vs HTTP, security properties
HTTPS provides some very important security properties that HTTP does not.
It provides confidentiality, integrity and authentication.
* Confidentiality: What you're loading cannot be snooped on by others.
Eve is on the same networking as you, and can listen into your
traffic - but if it's HTTPS they cannot read it. If it was plain HTTP
they could see what you were looking at and copy your session cookies
to potentially log in to sites as you.
* Integrity, Authentication: You know that if a document you recieve is
valid it is unmodified. Mallory cannot set up a man in the middle
attack and edit the documents in transit, if it was HTTP they could
do this with arp poisoning/cain and abel - and change all the images
on the pages you are looking at to rick astley.
Implementing confidentiality requires a cipher and a system for keys,
initialization vectors and such. It's rather involved.
Implementing integrity and authentication is less difficult. It can be
done using a public/private key pair and a hash algorithm.
#############
## Gopher with Trust-on-First-Use Integrity and Authentication
If we want to modify the gopher protocol to get Integrity and
Authentication we could do the following:
* Have a standardized endpoint where you can ask a server what its ssh
public key is.
* clients can trust these keys when they first contact the server.
* gopher documents can be signed (using ssh-keygen), clients can verify
these signatures (or ignore them, if you are just making a simple
implementation with no cryptography code in it).
See here for an excellent post by jvpernis about using ssh-keygen
to sign and verify signatures:
https://superuser.com/a/1616656
############
## Issues
The problem with TOFU is that it only works if you contact the real
server without any man in the middle on your first contact.
The advantage of TOFU is that it means an attack has to pull off the
attack on that specific moment to win.
Another issue is key revocation. If a server needs to revoke its key
you will need to trust its new key.
##############
## Conclusion
Overall the TOFU model would add some security to gopher but it is
difficult to trust it as strongly as we trust HTTPS.
The TOFU model is much simpler than the CA model. It would be possible
to create extensions like accessing the SSH public key over HTTPS, but
I feel like a self contained system is preferrable.
Implementations could just invoke the ssh-keygen tool, they would only
need to do this once per document published. Not once per document
served like in the case of HTTPS.
Alternatively they could reimplement the cryptographic primitives
involved. This is not unrealistic, but reimplementing OpenSSL is
unrealistic.
This proposal also allows implementations to just drop the crypto stuff
and still work.
#############
## Elsewhere
This post is also available on my gist blog
https://gist.github.com/rain-1/41c7c0cf54155169c2c9d6a5e1625d65
