net: add a test to ensure that our TLS handshake doesn't get too large.

third_party/tlslite/tlslite/messages.py

 """Classes representing TLS messages."""
 
 from utils.compat import *
 from utils.cryptomath import *
 from errors import *
 from utils.codec import *
 from constants import *
 from X509 import X509
 from X509CertChain import X509CertChain
 
@@ skipping 113 matching lines @@
         self.contentType = ContentType.handshake
         self.ssl2 = ssl2
         self.client_version = (0,0)
         self.random = createByteArrayZeros(32)
         self.session_id = createByteArraySequence([])
         self.cipher_suites = []         # a list of 16-bit values
         self.certificate_types = [CertificateType.x509]
         self.compression_methods = []   # a list of 8-bit values
         self.srp_username = None        # a string
         self.channel_id = False
+        # client_hello_length is the length of the ClientHello record - i.e.
+        # including the handshake type byte and 3 byte handshake length.
+        self.client_hello_length = 0
 
     def create(self, version, random, session_id, cipher_suites,
                certificate_types=None, srp_username=None):
         self.client_version = version
         self.random = random
         self.session_id = session_id
         self.cipher_suites = cipher_suites
         self.certificate_types = certificate_types
         self.compression_methods = [0]
         self.srp_username = srp_username
         return self
 
     def parse(self, p):
         if self.ssl2:
             self.client_version = (p.get(1), p.get(1))
             cipherSpecsLength = p.get(2)
             sessionIDLength = p.get(2)
             randomLength = p.get(2)
             self.cipher_suites = p.getFixList(3, int(cipherSpecsLength/3))
             self.session_id = p.getFixBytes(sessionIDLength)
             self.random = p.getFixBytes(randomLength)
             if len(self.random) < 32:
                 zeroBytes = 32-len(self.random)
                 self.random = createByteArrayZeros(zeroBytes) + self.random
             self.compression_methods = [0]#Fake this value
 
             #We're not doing a stopLengthCheck() for SSLv2, oh well..
         else:
+            self.client_hello_length = len(p.bytes) - p.index

[wtc, 2013/07/24 19:25:10]

I didn't verify the correctness of this expression because I don't know
this file well, but this expression looks correct and it also appears on
line 496.

+            # Account for the handshake type byte which has already been
+            # removed.
+            self.client_hello_length += 1
+
             p.startLengthCheck(3)
             self.client_version = (p.get(1), p.get(1))
             self.random = p.getFixBytes(32)
             self.session_id = p.getVarBytes(1)
             self.cipher_suites = p.getVarList(2, 2)
             self.compression_methods = p.getVarList(1, 1)
             if not p.atLengthCheck():
                 totalExtLength = p.get(2)
                 soFar = 0
                 while soFar != totalExtLength:
@@ skipping 436 matching lines @@
     def create(self, bytes):
         self.bytes = bytes
         return self
 
     def parse(self, p):
         self.bytes = p.bytes
         return self
 
     def write(self):
         return self.bytes