Add TLS-SRP (RFC 5054) support

third_party/tlslite/tlslite/TLSConnection.py

 """
 MAIN CLASS FOR TLS LITE (START HERE!).
 """
 from __future__ import generators
 
 import socket
 from utils.compat import formatExceptionTrace
 from TLSRecordLayer import TLSRecordLayer
 from Session import Session
 from constants import *
@@ skipping 496 matching lines @@
 
         #Or send ClientHello (without)
         else:
             clientHello = ClientHello()
             clientHello.create(settings.maxVersion, clientRandom,
                                createByteArraySequence([]), cipherSuites,
                                certificateTypes, srpUsername)
         for result in self._sendMsg(clientHello):
             yield result
 
-        #Get ServerHello (or missing_srp_username)
+        #Get ServerHello (or unknown_psk_identity)
         for result in self._getMsg((ContentType.handshake,
                                   ContentType.alert),
                                   HandshakeType.server_hello):
             if result in (0,1):
                 yield result
             else:
                 break
         msg = result
 
         if isinstance(msg, ServerHello):
             serverHello = msg
         elif isinstance(msg, Alert):
             alert = msg
 
-            #If it's not a missing_srp_username, re-raise
-            if alert.description != AlertDescription.missing_srp_username:
+            #If it's not a unknown_psk_identity, re-raise
+            if alert.description != AlertDescription.unknown_psk_identity:
                 self._shutdown(False)
                 raise TLSRemoteAlert(alert)
 
-            #If we're not in SRP callback mode, we won't have offered SRP
-            #without a username, so we shouldn't get this alert
-            if not srpCallback:
-                for result in self._sendError(\
-                                AlertDescription.unexpected_message):
-                    yield result
-            srpParams = srpCallback()
-            #If the callback returns None, cancel the handshake
-            if srpParams == None:
+            #Our SRP credentials were wrong, so try getting new ones.
+            if srpCallback:
+                srpParams = srpCallback()
+
+            #If we can't get different credentials, cancel the handshake
+            if srpParams == None or not srpCallback:
                 for result in self._sendError(AlertDescription.user_canceled):
                     yield result
 
             #Recursively perform handshake
             for result in self._handshakeClientAsyncHelper(srpParams,
                             None, None, None, None, settings, True):
                 yield result
             return
 
         #Get the server version.  Do this before anything else, so any
@@ skipping 696 matching lines @@
 
         #If we've selected an SRP suite, exchange keys and calculate
         #premaster secret:
         if cipherSuite in CipherSuite.srpSuites + CipherSuite.srpRsaSuites:
 
             #If there's no SRP username...
             if not clientHello.srp_username:
 
                 #Ask the client to re-send ClientHello with one
                 for result in self._sendMsg(Alert().create(\
-                        AlertDescription.missing_srp_username,
-                        AlertLevel.warning)):
+                        AlertDescription.unknown_psk_identity,
+                        AlertLevel.fatal)):
                     yield result
 
                 #Get ClientHello
                 for result in self._getMsg(ContentType.handshake,
                         HandshakeType.client_hello):
                     if result in (0,1):
                         yield result
                     else:
                         break
                 clientHello = result
@@ skipping 42 matching lines @@
 
 
             #Get username
             self.allegedSrpUsername = clientHello.srp_username
 
             #Get parameters from username
             try:
                 entry = verifierDB[self.allegedSrpUsername]
             except KeyError:
                 for result in self._sendError(\
-                        AlertDescription.unknown_srp_username):
+                        AlertDescription.unknown_psk_identity):
                     yield result
             (N, g, s, v) = entry
 
             #Calculate server's ephemeral DH values (b, B)
             b = bytesToNumber(getRandomBytes(32))
             k = makeK(N, g)
             B = (powMod(g, b, N) + (k*v)) % N
 
             #Create ServerKeyExchange, signing it if necessary
             serverKeyExchange = ServerKeyExchange(cipherSuite)
@@ skipping 266 matching lines @@
         if len(publicKey) < settings.minKeySize:
             for result in self._sendError(AlertDescription.handshake_failure,
                     "Other party's public key too small: %d" % len(publicKey)):
                 yield result
         if len(publicKey) > settings.maxKeySize:
             for result in self._sendError(AlertDescription.handshake_failure,
                     "Other party's public key too large: %d" % len(publicKey)):
                 yield result
 
         yield publicKey, certChain