TLS version (in)tolerance scanner

Since it is impossible to make openssl command line tool send
TLSv1.3 Client Hello message, add a python based tool to perform
TLS version intolerance scan

cscan_tests/test_config.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2015 Hubert Kario
+# Released under Mozilla Public License Version 2.0
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+from tlslite.messages import ClientHello
+from tlslite.extensions import SNIExtension, SupportedGroupsExtension, \
+        ECPointFormatsExtension, NPNExtension, SignatureAlgorithmsExtension
+from tlslite.utils.codec import Parser
+from cscan.config import Firefox_42
+from cscan.extensions import RenegotiationExtension
+from cscan.constants import ExtensionType
+
+class TestFirefox(unittest.TestCase):
+    def test_firefox_42(self):
+        gen = Firefox_42()
+        ch = gen(bytearray(b'example.com'))
+
+        self.assertIsNotNone(ch)
+        self.assertIsInstance(ch, ClientHello)
+        self.assertEqual(len(ch.write()), 176)
+        self.assertEqual(ch.client_version, (3, 3))
+        self.assertEqual(gen.record_version, (3, 1))
+        self.assertEqual(len(ch.cipher_suites), 11)
+        self.assertIsInstance(ch.extensions[0], SNIExtension)
+        self.assertEqual(ch.extensions[1].extType,
+                         ExtensionType.renegotiation_info)
+        self.assertIsInstance(ch.extensions[2],
+                              SupportedGroupsExtension)
+        self.assertIsInstance(ch.extensions[3],
+                              ECPointFormatsExtension)
+        self.assertEqual(ch.extensions[4].extType,
+                         ExtensionType.session_ticket)
+        # bug in tlslite-ng, removes NPN extensions from provided extensions
+        #self.assertIsInstance(ch.extensions[5],
+        #                      NPNExtension)
+        self.assertEqual(ch.extensions[5].extType,
+                         ExtensionType.alpn)
+        self.assertEqual(ch.extensions[6].extType,
+                         ExtensionType.status_request)
+        self.assertIsInstance(ch.extensions[7],
+                              SignatureAlgorithmsExtension)
+        self.assertEqual(ch.compression_methods, [0])
+
+
+if __name__ == "__main__":
+    unittest.main()

cscan_tests/test_extensions.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2015 Hubert Kario
+# Released under Mozilla Public License Version 2.0
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+from tlslite.utils.codec import Parser
+from cscan.extensions import KeyShareExtension
+from cscan.constants import GroupName
+
+class TestKeyShareExtension(unittest.TestCase):
+    def test___init__(self):
+        ext = KeyShareExtension()
+
+        self.assertIsNotNone(ext)
+
+    def test_create(self):
+        ext = KeyShareExtension()
+
+        ext.create([(1, bytearray(b'\x12')),
+                    (2, bytearray(b'\x33'))])
+
+        self.assertEqual(ext.client_shares, [(1, bytearray(b'\x12')),
+                                             (2, bytearray(b'\x33'))])
+
+    def test_write(self):
+        ext = KeyShareExtension()
+
+        ext.create([(GroupName.secp256r1, bytearray(b'\xff\xfa')),
+                    (GroupName.ffdhe2048, bytearray(b'\xaf\xaa'))])
+
+        data = ext.write()
+
+        self.assertEqual(data, bytearray(
+            b'\x00\x2a\x00\x0d'
+            b'\x00\x0b'
+            b'\x00\x17\x02\xff\xfa'
+            b'\x01\x00\x00\x02\xaf\xaa'))
+
+    def test_write_with_no_data(self):
+        ext = KeyShareExtension()
+
+        data = ext.write()
+
+        self.assertEqual(data, bytearray(b'\x00\x2a\x00\x00'))
+
+    def test_parse(self):
+        parser = Parser(bytearray(
+            #b'\x00\x2a\x00\x0d'
+            b'\x00\x0b'
+            b'\x00\x17\x02\xff\xfa'
+            b'\x01\x00\x00\x02\xaf\xaa'))
+
+        ext = KeyShareExtension()
+        ext.parse(parser)
+
+        self.assertEqual(ext.client_shares,
+                         [(GroupName.secp256r1, bytearray(b'\xff\xfa')),
+                          (GroupName.ffdhe2048, bytearray(b'\xaf\xaa'))])
+
+    def test_parse_with_no_data(self):
+        parser = Parser(bytearray())
+
+        ext = KeyShareExtension()
+        ext.parse(parser)
+
+        self.assertIsNone(ext.client_shares)
+
+    def test___repr__(self):
+        ext = KeyShareExtension()
+        ext.create([(1, bytearray(b'\xff'))])
+
+        self.assertEqual("KeyShareExtension([(1, bytearray(b\'\\xff\'))])",
+                         repr(ext))