1 Introduction 2 License/Acknowledgements 3 Installation 4 Getting Started with the Command-Line Tools 5 Getting Started with the Library 6 Using TLS Lite with httplib 7 Using TLS Lite with poplib or imaplib 8 Using TLS Lite with smtplib 9 Using TLS Lite with SocketServer 10 Using TLS Lite with asyncore 11 SECURITY CONSIDERATIONS 12 History
TLS Lite is an open source python library that implements SSL and TLS. TLS Lite supports RSA and SRP ciphersuites. TLS Lite is pure python, however it can use other libraries for faster crypto operations. TLS Lite integrates with several stdlib neworking libraries.
API documentation is available in the 'docs' directory.
If you have questions or feedback, feel free to contact me. For discussing improvements to tlslite, also see '[email protected]'.
TLS Lite is written (mostly) by Trevor Perrin. It includes code from Bram Cohen, Google, Kees Bos, Sam Rushing, Dimitris Moraitis, Marcelo Fernandez, Martin von Loewis, Dave Baggett, Yngve N. Pettersen (ported by Paul Sokolovsky), Mirko Dziadzka, David Benjamin, and Hubert Kario.
All code in TLS Lite has either been dedicated to the public domain by its authors, or placed under a BSD-style license. See the LICENSE file for details.
Thanks to Edward Loper for Epydoc, which generated the API docs.
Requirements: Python 2.6 or higher is required. Python 3 is supported.
If you have the M2Crypto interface to OpenSSL, this will be used for fast RSA operations and fast ciphers.
If you have pycrypto this will be used for fast RSA operations and fast ciphers.
If you have the GMPY interface to GMP, this will be used for fast RSA and SRP operations.
These modules don't need to be present at installation - you can install them any time.
Run 'python setup.py install'
Test the Installation:
If both say "Test succeeded" at the end, you're ready to go.
tlslite installs two command-line scripts: 'tlsdb.py' and 'tls.py'.
'tls.py' lets you run test clients and servers. It can be used for testing other TLS implementations, or as example code. Note that 'tls.py server' runs an HTTPS server which will serve files rooted at the current directory by default, so be careful.
'tlsdb.py' lets you manage SRP verifier databases. These databases are used by a TLS server when authenticating clients with SRP.
To run an X.509 server, go to the ./tests directory and do:
tls.py server -k serverX509Key.pem -c serverX509Cert.pem localhost:4443
Try connecting to the server with a web browser, or with:
tls.py client localhost:4443
To run an X.509 server using a TACK, install TACKpy, then run the same server command as above with added arguments:
... -t TACK1.pem localhost:4443
To run an SRP server, try something like:
tlsdb.py createsrp verifierDB tlsdb.py add verifierDB alice abra123cadabra 1024 tlsdb.py add verifierDB bob swordfish 2048
tls.py server -v verifierDB localhost:4443
Then try connecting to the server with:
tls.py client localhost:4443 alice abra123cadabra
To run an HTTPS server with less typing, run ./tests/httpsserver.sh.
To run an HTTPS client, run ./tests/httpsclient.py.
Whether you're writing a client or server, there are six steps:
TLS Lite also integrates with several stdlib python libraries. See the sections following this one for details.
Below demonstrates a socket connection to Amazon's secure site.
from socket import * sock = socket(AF_INET, SOCK_STREAM) sock.connect( ("www.amazon.com", 443) )
You can import tlslite objects individually, such as: from tlslite import TLSConnection
Or import the most useful objects through: from tlslite.api import *
Then do: connection = TLSConnection(sock)
If you're a client, there's two different handshake functions you can call, depending on how you want to authenticate:
connection.handshakeClientCert() connection.handshakeClientCert(certChain, privateKey)
The ClientCert function without arguments is used when connecting to a site like Amazon, which doesn't require client authentication, but which will authenticate itself using an X.509 certificate chain.
The ClientCert function can also be used to do client authentication with an X.509 certificate chain and corresponding private key. To use X.509 chains, you'll need some way of creating these, such as OpenSSL (see http://www.openssl.org/docs/HOWTO/ for details).
Below is an example of loading an X.509 chain and private key:
from tlslite import X509, X509CertChain, parsePEMKey s = open("./test/clientX509Cert.pem").read() x509 = X509() x509.parse(s) certChain = X509CertChain([x509]) s = open("./test/clientX509Key.pem").read() privateKey = parsePEMKey(s, private=True)
The SRP function does mutual authentication with a username and password - see RFC 5054 for details.
If you want more control over the handshake, you can pass in a HandshakeSettings instance. For example, if you're performing SRP, but you only want to use SRP parameters of at least 2048 bits, and you only want to use the AES-256 cipher, and you only want to allow TLS (version 3.1), not SSL (version 3.0), you can do:
settings = HandshakeSettings() settings.minKeySize = 2048 settings.cipherNames = ["aes256"] settings.minVersion = (3,1) settings.useExperimentalTACKExtension = True # Needed for TACK support
connection.handshakeClientSRP("alice", "abra123cadabra", settings=settings)
If you want to check the server's certificate using TACK, you should set the "useExperiementalTACKExtension" value in HandshakeSettings. (Eventually, TACK support will be enabled by default, but for now it is an experimental feature which relies on a temporary TLS Extension number, and should not be used for production software.) This will cause the client to request the server to send you a TACK (and/or any TACK Break Signatures):
Finally, every TLSConnection has a session object. You can try to resume a previous session by passing in the session object from the old session. If the server remembers this old session and supports resumption, the handshake will finish more quickly. Otherwise, the full handshake will be done. For example:
connection.handshakeClientSRP("alice", "abra123cadabra") . . oldSession = connection.session connection2.handshakeClientSRP("alice", "abra123cadabra", session= oldSession)
If you're a server, there's only one handshake function, but you can pass it several different parameters, depending on which types of authentication you're willing to perform.
To perform SRP authentication, you have to pass in a database of password verifiers. The VerifierDB class manages an in-memory or on-disk verifier database.
verifierDB = VerifierDB("./test/verifierDB") verifierDB.open() connection.handshakeServer(verifierDB=verifierDB)
To perform authentication with a certificate and private key, the server must load these as described in the previous section, then pass them in. If the server sets the reqCert boolean to True, a certificate chain will be requested from the client.
connection.handshakeServer(certChain=certChain, privateKey=privateKey, reqCert=True)
You can pass in a verifier database and/or a certificate chain+private key. The client will use one or both to authenticate the server.
You can also pass in a HandshakeSettings object, as described in the last section, for finer control over handshaking details.
If you are passing in a certificate chain+private key, you may additionally provide a TACK to assist the client in authenticating your certificate chain. This requires the TACKpy library. Load a TACKpy.TACK object, then do:
settings = HandshakeSettings() settings.useExperimentalTACKExtension = True # Needed for TACK support
connection.handshakeServer(certChain=certChain, privateKey=privateKey, tack=tack, settings=settings)
Finally, the server can maintain a SessionCache, which will allow clients to use session resumption:
sessionCache = SessionCache() connection.handshakeServer(verifierDB=verifierDB, sessionCache=sessionCache)
It should be noted that the session cache, and the verifier databases, are all thread-safe.
If the handshake completes without raising an exception, authentication results will be stored in the connection's session object. The following variables will be populated if applicable, or else set to None:
connection.session.srpUsername # string connection.session.clientCertChain # X509CertChain connection.session.serverCertChain # X509CertChain connection.session.tackExt # TACKpy.TACK_Extension
X.509 chain objects return the end-entity fingerprint via getFingerprint(), and ignore the other certificates.
TACK objects return the (validated) TACK ID via getTACKID().
To save yourself the trouble of inspecting certificates after the handshake, you can pass a Checker object into the handshake function. The checker will be called if the handshake completes successfully. If the other party isn't approved by the checker, a subclass of TLSAuthenticationError will be raised.
If the handshake fails for any reason, including a Checker error, an exception will be raised and the socket will be closed. If the socket timed out or was unexpectedly closed, a socket.error or TLSAbruptCloseError will be raised.
Otherwise, either a TLSLocalAlert or TLSRemoteAlert will be raised, depending on whether the local or remote implementation signalled the error. The exception object has a 'description' member which identifies the error based on the codes in RFC 2246. A TLSLocalAlert also has a 'message' string that may have more details.
Example of handling a remote alert:
try: [...] except TLSRemoteAlert as alert: if alert.description == AlertDescription.unknown_psk_identity: print "Unknown user." [...]
Below are some common alerts and their probable causes, and whether they are signalled by the client or server.
Now that you have a connection, you can call read() and write() as if it were a socket.SSL object. You can also call send(), sendall(), recv(), and makefile() as if it were a socket. These calls may raise TLSLocalAlert, TLSRemoteAlert, socket.error, or TLSAbruptCloseError, just like the handshake functions.
Once the TLS connection is closed by the other side, calls to read() or recv() will return an empty string. If the socket is closed by the other side without first closing the TLS connection, calls to read() or recv() will return a TLSAbruptCloseError, and calls to write() or send() will return a socket.error.
When you're finished sending data, you should call close() to close the connection and socket. When the connection is closed properly, the session object can be used for session resumption.
If an exception is raised the connection will be automatically closed; you don't need to call close(). Furthermore, you will probably not be able to re-use the socket, the connection object, or the session object, and you shouldn't even try.
By default, calling close() will close the underlying socket. If you set the connection's closeSocket flag to False, the socket will remain open after close. (NOTE: some TLS implementations will not respond properly to the close_notify alert that close() generates, so the connection will hang if closeSocket is set to True.)
TLS Lite comes with an HTTPTLSConnection class that extends httplib to work over SSL/TLS connections. Depending on how you construct it, it will do different types of authentication.
#No authentication whatsoever h = HTTPTLSConnection("www.amazon.com", 443) h.request("GET", "") r = h.getresponse() [...]
#Authenticate server based on its TACK ID h = HTTPTLSConnection("localhost", 4443, tackID="B3ARS.EQ61B.F34EL.9KKLN.3WEW5", hardTack=False) [...]
#Mutually authenticate with SRP h = HTTPTLSConnection("localhost", 443, username="alice", password="abra123cadabra") [...]
TLS Lite comes with POP3_TLS and IMAP4_TLS classes that extend poplib and imaplib to work over SSL/TLS connections. These classes can be constructed with the same parameters as HTTPTLSConnection (see previous section), and behave similarly.
#To connect to a POP3 server over SSL and display its fingerprint: from tlslite.api import * p = POP3_TLS("---------.net", port=995) print p.sock.session.serverCertChain.getFingerprint() [...]
#To connect to an IMAP server once you know its fingerprint: from tlslite.api import * i = IMAP4_TLS("cyrus.andrew.cmu.edu", x509Fingerprint="00c14371227b3b677ddb9c4901e6f2aee18d3e45") [...]
TLS Lite comes with an SMTP_TLS class that extends smtplib to work over SSL/TLS connections. This class accepts the same parameters as HTTPTLSConnection (see previous section), and behaves similarly. Depending on how you call starttls(), it will do different types of authentication.
#To connect to an SMTP server once you know its fingerprint: from tlslite.api import * s = SMTP_TLS("----------.net", port=587) s.ehlo() s.starttls(x509Fingerprint="7e39be84a2e3a7ad071752e3001d931bf82c32dc") [...]
You can use TLS Lite to implement servers using Python's SocketServer framework. TLS Lite comes with a TLSSocketServerMixIn class. You can combine this with a TCPServer such as HTTPServer. To combine them, define a new class that inherits from both of them (with the mix-in first). Then implement the handshake() method, doing some sort of server handshake on the connection argument. If the handshake method returns True, the RequestHandler will be triggered. See the tests/httpsserver.py example.
TLS Lite can be used with subclasses of asyncore.dispatcher. See the comments in TLSAsyncDispatcherMixIn.py for details. This is still experimental, and may not work with all asyncore.dispatcher subclasses.
TLS Lite is beta-quality code. It hasn't received much security analysis. Use at your own risk.
TLS Lite does NOT verify certificates by default.
TLS Lite's pure-python ciphers are probably vulnerable to timing attacks.
TLS Lite is probably vulnerable to the "Lucky 13" timing attack if AES or 3DES are used, or the weak cipher RC4 otherwise. This unhappy situation will remain until TLS Lite implements authenticated-encryption ciphersuites (like GCM), or RFC 7366.
0.4.9 - 08/11/2015
0.4.0 - 2/11/2012
0.3.9.x - 2/7/2012
Much code cleanup, in particular decomposing the handshake functions so they are readable. The main new feature is support for TACK, an experimental authentication method that provides a new way to pin server certificates (See https://github.com/moxie0/Convergence/wiki/TACK ).
0.3.8 - 2/21/2005