Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 6 ■ TLS AND SSL
the defaults for the wrap_socket() call in the Standard Library—is if you need to speak to browsers or
other third-party clients that might not have upgraded to full-fledged TLS yet.
Loose Ends
When adding cryptography to your application, it is always a good idea to read up-to-date documentation.
The advice given in this chapter would have been quite different if this revision of the book had happened
even just one or two years earlier, and in two or three more years it will doubtless be out of date.
In particular, the idea has been around for a long time in the public-key cryptography literature that
there should exist certificate revocation lists, where client certificates and even certificate-authority
certificates could be listed if they are discovered to have been compromised and must no longer be
trusted. That way, instead of everyone waiting for operating system updates or browser upgrades to
bring the news that an old CA certificate should no longer be trusted, they could instantly be protected
against any client certificates minted with the stolen private key.
Also, security vulnerabilities continue to be discovered not only in particular programs but also in
the design of various security protocols themselves—SSL version 2 was, in fact, the victim of just such a
discovery in the mid-1990s, which is why many people simply turn it off as an option when using TLS.
All of which is to say: use this chapter as a basic API reference and introduction to the whole topic of
secure sockets, but consult something more up-to-date if you are creating new software more than a
year after this book comes out, to make sure the protocols still operate well if used as shown here. As of
this writing, the Standard Library documentation, Python blogs, and Stack Overflow questions about
cryptography are all good places to look.
Summary
Computer security is a large and complicated subject. At its core is the fact that an intruder or
troublemaker will take advantage of almost any mistake you make—even an apparently very small one—
to try to leverage control over your systems and software.
Networks are the locus of much security effort because the IP protocols, by default, copy all your
information into packets verbatim, where it can be read by anyone watching your packets go past.
Passive sniffing, man-in-the-middle attacks, connection hijacking, and replay attacks are all possible if
an adversary has control over the network between a client and server.
Fortunately, mathematicians have invented public-key cryptography, which has been packaged as
the TLS protocol for protecting IP sockets. It grew out of an older, less secure protocol named SSL, from
which most software libraries that speak TLS take their name.
The Python Standard Library now supplies an ssl package (though it has to be downloaded
separately for Python 2.5), which can leverage the OpenSSL library to secure your own application
sockets. This makes it impossible for a third party to masquerade as a properly certified server machine,
and also encrypts all data so that an observer cannot determine what your client and server programs
are saying to one another.
There are two keys to using the ssl package. First, you should always wrap the bare socket you
create with its wrap_socket() function, giving the right arguments for the kind of connection and
certificate assurances that you need. Second, if you expect the other side to provide a certificate, then
you should run match_hostname() to make sure that they are claiming the identity that you expect.
The security playing field shifts every few years, with old protocols obsoleted and new ones
developed, so keep abreast of news if you are writing security-sensitive applications.
98