diff --git a/src/model/transport.py b/src/model/transport.py
index 0c2ee16..91f7c8f 100644
--- a/src/model/transport.py
+++ b/src/model/transport.py
@@ -55,7 +55,6 @@ from cryptography.hazmat.primitives.ciphers import algorithms, Cipher, modes
 import paramiko
 from paramiko import util
 from paramiko.auth_handler import AuthHandler
-from paramiko.ssh_gss import GSSAuth
 from paramiko.channel import Channel
 from paramiko.common import (
     xffffffff,
@@ -105,19 +104,15 @@ from paramiko.common import (
     MSG_NAMES,
 )
 from paramiko.compress import ZlibCompressor, ZlibDecompressor
-from paramiko.dsskey import DSSKey
 from paramiko.ed25519key import Ed25519Key
 from paramiko.kex_curve25519 import KexCurve25519
-from paramiko.kex_gex import KexGex, KexGexSHA256
-from paramiko.kex_group1 import KexGroup1
-from paramiko.kex_group14 import KexGroup14, KexGroup14SHA256
+from paramiko.kex_gex import KexGexSHA256
+from paramiko.kex_group14 import KexGroup14SHA256
 from paramiko.kex_group16 import KexGroup16SHA512
 from paramiko.kex_ecdh_nist import KexNistp256, KexNistp384, KexNistp521
-from paramiko.kex_gss import KexGSSGex, KexGSSGroup1, KexGSSGroup14
 from paramiko.message import Message
 from paramiko.packet import Packetizer, NeedRekeyException
 from paramiko.primes import ModulusPack
-from paramiko.py3compat import string_types, long, byte_ord, b, input, PY2
 from paramiko.rsakey import RSAKey
 from paramiko.ecdsakey import ECDSAKey
 from paramiko.server import ServerInterface
@@ -128,7 +123,7 @@ from paramiko.ssh_exception import (
     ChannelException,
     ProxyCommandFailure,
 )
-from paramiko.util import retry_on_signal, ClosingContextManager, clamp_value
+from paramiko.util import ClosingContextManager, clamp_value
 
 
 # for thread cleanup
@@ -192,7 +187,6 @@ class Transport(threading.Thread, ClosingContextManager):
         "ecdsa-sha2-nistp384",
         "ecdsa-sha2-nistp521",
         "ssh-rsa",
-        "ssh-dss",
     )
     _preferred_kex = (
         "ecdh-sha2-nistp256",
@@ -201,17 +195,9 @@ class Transport(threading.Thread, ClosingContextManager):
         "diffie-hellman-group16-sha512",
         "diffie-hellman-group-exchange-sha256",
         "diffie-hellman-group14-sha256",
-        "diffie-hellman-group-exchange-sha1",
-        "diffie-hellman-group14-sha1",
-        "diffie-hellman-group1-sha1",
     )
     if KexCurve25519.is_available():
         _preferred_kex = ("curve25519-sha256@libssh.org",) + _preferred_kex
-    _preferred_gsskex = (
-        "gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==",
-        "gss-group14-sha1-toWM5Slw5Ew8Mqkay+al2g==",
-        "gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==",
-    )
     _preferred_compression = ("none",)
 
     _cipher_info = {
@@ -273,8 +259,6 @@ class Transport(threading.Thread, ClosingContextManager):
     _key_info = {
         "ssh-rsa": RSAKey,
         "ssh-rsa-cert-v01@openssh.com": RSAKey,
-        "ssh-dss": DSSKey,
-        "ssh-dss-cert-v01@openssh.com": DSSKey,
         "ecdsa-sha2-nistp256": ECDSAKey,
         "ecdsa-sha2-nistp256-cert-v01@openssh.com": ECDSAKey,
         "ecdsa-sha2-nistp384": ECDSAKey,
@@ -286,15 +270,9 @@ class Transport(threading.Thread, ClosingContextManager):
     }
 
     _kex_info = {
-        "diffie-hellman-group1-sha1": KexGroup1,
-        "diffie-hellman-group14-sha1": KexGroup14,
-        "diffie-hellman-group-exchange-sha1": KexGex,
         "diffie-hellman-group-exchange-sha256": KexGexSHA256,
         "diffie-hellman-group14-sha256": KexGroup14SHA256,
         "diffie-hellman-group16-sha512": KexGroup16SHA512,
-        "gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGroup1,
-        "gss-group14-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGroup14,
-        "gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGex,
         "ecdh-sha2-nistp256": KexNistp256,
         "ecdh-sha2-nistp384": KexNistp384,
         "ecdh-sha2-nistp521": KexNistp521,
@@ -319,8 +297,6 @@ class Transport(threading.Thread, ClosingContextManager):
         sock,
         default_window_size=DEFAULT_WINDOW_SIZE,
         default_max_packet_size=DEFAULT_MAX_PACKET_SIZE,
-        gss_kex=False,
-        gss_deleg_creds=True,
         disabled_algorithms=None,
     ):
         """
@@ -362,12 +338,6 @@ class Transport(threading.Thread, ClosingContextManager):
         :param int default_max_packet_size:
             sets the default max packet size on the transport. (defaults to
             32768)
-        :param bool gss_kex:
-            Whether to enable GSSAPI key exchange when GSSAPI is in play.
-            Default: ``False``.
-        :param bool gss_deleg_creds:
-            Whether to enable GSSAPI credential delegation when GSSAPI is in
-            play. Default: ``True``.
         :param dict disabled_algorithms:
             If given, must be a dictionary mapping algorithm type to an
             iterable of algorithm identifiers, which will be disabled for the
@@ -388,15 +358,13 @@ class Transport(threading.Thread, ClosingContextManager):
         .. versionchanged:: 1.15
             Added the ``default_window_size`` and ``default_max_packet_size``
             arguments.
-        .. versionchanged:: 1.15
-            Added the ``gss_kex`` and ``gss_deleg_creds`` kwargs.
         .. versionchanged:: 2.6
             Added the ``disabled_algorithms`` kwarg.
         """
         self.active = False
         self.hostname = None
 
-        if isinstance(sock, string_types):
+        if isinstance(sock, str):
             # convert "host:port" into (host, port)
             hl = sock.split(":", 1)
             self.hostname = hl[0]
@@ -419,7 +387,7 @@ class Transport(threading.Thread, ClosingContextManager):
                     sock = socket.socket(af, socket.SOCK_STREAM)
                     sock.settimeout(1)
                     try:
-                        retry_on_signal(lambda: sock.connect((hostname, port)))
+                        sock.connect((hostname, port))
                     except socket.error as e:
                         reason = str(e)
                     else:
@@ -448,16 +416,6 @@ class Transport(threading.Thread, ClosingContextManager):
         self.host_key_type = None
         self.host_key = None
 
-        # GSS-API / SSPI Key Exchange
-        self.use_gss_kex = gss_kex
-        # This will be set to True if GSS-API Key Exchange was performed
-        self.gss_kex_used = False
-        self.kexgss_ctxt = None
-        self.gss_host = None
-        if self.use_gss_kex:
-            self.kexgss_ctxt = GSSAuth("gssapi-keyex", gss_deleg_creds)
-            self._preferred_kex = self._preferred_gsskex + self._preferred_kex
-
         # state used during negotiation
         self.kex_engine = None
         self.H = None
@@ -542,7 +500,7 @@ class Transport(threading.Thread, ClosingContextManager):
         """
         Returns a string representation of this object, for debugging.
         """
-        id_ = hex(long(id(self)) & xffffffff)
+        id_ = hex(int(id(self)) & xffffffff)
         out = "<paramiko.Transport at {}".format(id_)
         if not self.active:
             out += " (unconnected)"
@@ -585,40 +543,6 @@ class Transport(threading.Thread, ClosingContextManager):
         """
         return SecurityOptions(self)
 
-    def set_gss_host(self, gss_host, trust_dns=True, gssapi_requested=True):
-        """
-        Normalize/canonicalize ``self.gss_host`` depending on various factors.
-
-        :param str gss_host:
-            The explicitly requested GSS-oriented hostname to connect to (i.e.
-            what the host's name is in the Kerberos database.) Defaults to
-            ``self.hostname`` (which will be the 'real' target hostname and/or
-            host portion of given socket object.)
-        :param bool trust_dns:
-            Indicates whether or not DNS is trusted; if true, DNS will be used
-            to canonicalize the GSS hostname (which again will either be
-            ``gss_host`` or the transport's default hostname.)
-            (Defaults to True due to backwards compatibility.)
-        :param bool gssapi_requested:
-            Whether GSSAPI key exchange or authentication was even requested.
-            If not, this is a no-op and nothing happens
-            (and ``self.gss_host`` is not set.)
-            (Defaults to True due to backwards compatibility.)
-        :returns: ``None``.
-        """
-        # No GSSAPI in play == nothing to do
-        if not gssapi_requested:
-            return
-        # Obtain the correct host first - did user request a GSS-specific name
-        # to use that is distinct from the actual SSH target hostname?
-        if gss_host is None:
-            gss_host = self.hostname
-        # Finally, canonicalize via DNS if DNS is trusted.
-        if trust_dns and gss_host is not None:
-            gss_host = socket.getfqdn(gss_host)
-        # And set attribute for reference later.
-        self.gss_host = gss_host
-
     def start_client(self, event=None, timeout=None):
         """
         Negotiate a new SSH2 session as a client.  This is the first step after
@@ -749,11 +673,11 @@ class Transport(threading.Thread, ClosingContextManager):
         as a server, the host key is used to sign certain packets during the
         SSH2 negotiation, so that the client can trust that we are who we say
         we are.  Because this is used for signing, the key must contain private
-        key info, not just the public half.  Only one key of each type (RSA or
-        DSS) is kept.
+        key info, not just the public half.  Only one key of each type (i.e.
+        RSA) is kept.
 
         :param .PKey key:
-            the host key to add, usually an `.RSAKey` or `.DSSKey`.
+            the host key to add, usually an `.RSAKey`.
         """
         self.server_key_dict[key.get_name()] = key
 
@@ -763,7 +687,7 @@ class Transport(threading.Thread, ClosingContextManager):
         client, this method will return the negotiated host key.  If only one
         type of host key was set with `add_server_key`, that's the only key
         that will ever be returned.  But in cases where you have set more than
-        one type of host key (for example, an RSA key and a DSS key), the key
+        one type of host key (for example, an RSA key and another key), the key
         type will be negotiated by the client, and this method will return the
         key of the type agreed on.  If the host key has not been negotiated
         yet, ``None`` is returned.  In client mode, the behavior is undefined.
@@ -1123,7 +1047,7 @@ class Transport(threading.Thread, ClosingContextManager):
         m = Message()
         m.add_byte(cMSG_IGNORE)
         if byte_count is None:
-            byte_count = (byte_ord(os.urandom(1)) % 32) + 10
+            byte_count = (os.urandom(1)[0] % 32) + 10
         m.add_bytes(os.urandom(byte_count))
         self._send_user_message(m)
 
@@ -1238,11 +1162,6 @@ class Transport(threading.Thread, ClosingContextManager):
         username="",
         password=None,
         pkey=None,
-        gss_host=None,
-        gss_auth=False,
-        gss_kex=False,
-        gss_deleg_creds=True,
-        gss_trust_dns=True,
     ):
         """
         Negotiate an SSH2 session, and optionally verify the server's host key
@@ -1273,40 +1192,17 @@ class Transport(threading.Thread, ClosingContextManager):
         :param .PKey pkey:
             a private key to use for authentication, if you want to use private
             key authentication; otherwise ``None``.
-        :param str gss_host:
-            The target's name in the kerberos database. Default: hostname
-        :param bool gss_auth:
-            ``True`` if you want to use GSS-API authentication.
-        :param bool gss_kex:
-            Perform GSS-API Key Exchange and user authentication.
-        :param bool gss_deleg_creds:
-            Whether to delegate GSS-API client credentials.
-        :param gss_trust_dns:
-            Indicates whether or not the DNS is trusted to securely
-            canonicalize the name of the host being connected to (default
-            ``True``).
 
         :raises: `.SSHException` -- if the SSH2 negotiation fails, the host key
             supplied by the server is incorrect, or authentication fails.
-
-        .. versionchanged:: 2.3
-            Added the ``gss_trust_dns`` argument.
         """
         if hostkey is not None:
             self._preferred_keys = [hostkey.get_name()]
 
-        self.set_gss_host(
-            gss_host=gss_host,
-            trust_dns=gss_trust_dns,
-            gssapi_requested=gss_kex or gss_auth,
-        )
-
         self.start_client()
 
         # check host key if we were given one
-        # If GSS-API Key Exchange was performed, we are not required to check
-        # the host key.
-        if (hostkey is not None) and not gss_kex:
+        if hostkey is not None:
             key = self.get_remote_server_key()
             if (
                 key.get_name() != hostkey.get_name()
@@ -1330,18 +1226,8 @@ class Transport(threading.Thread, ClosingContextManager):
                 DEBUG, "Host key verified ({})".format(hostkey.get_name())
             )
 
-        if (pkey is not None) or (password is not None) or gss_auth or gss_kex:
-            if gss_auth:
-                self._log(
-                    DEBUG, "Attempting GSS-API auth... (gssapi-with-mic)"
-                )  # noqa
-                self.auth_gssapi_with_mic(
-                    username, self.gss_host, gss_deleg_creds
-                )
-            elif gss_kex:
-                self._log(DEBUG, "Attempting GSS-API auth... (gssapi-keyex)")
-                self.auth_gssapi_keyex(username)
-            elif pkey is not None:
+        if (pkey is not None) or (password is not None):
+            if pkey is not None:
                 self._log(DEBUG, "Attempting public-key auth...")
                 self.auth_publickey(username, pkey)
             else:
@@ -1668,55 +1554,6 @@ class Transport(threading.Thread, ClosingContextManager):
 
         return self.auth_interactive(username, handler, submethods)
 
-    def auth_gssapi_with_mic(self, username, gss_host, gss_deleg_creds):
-        """
-        Authenticate to the Server using GSS-API / SSPI.
-
-        :param str username: The username to authenticate as
-        :param str gss_host: The target host
-        :param bool gss_deleg_creds: Delegate credentials or not
-        :return: list of auth types permissible for the next stage of
-                 authentication (normally empty)
-        :raises: `.BadAuthenticationType` -- if gssapi-with-mic isn't
-            allowed by the server (and no event was passed in)
-        :raises:
-            `.AuthenticationException` -- if the authentication failed (and no
-            event was passed in)
-        :raises: `.SSHException` -- if there was a network error
-        """
-        if (not self.active) or (not self.initial_kex_done):
-            # we should never try to authenticate unless we're on a secure link
-            raise SSHException("No existing session")
-        my_event = threading.Event()
-        self.auth_handler = AuthHandler(self)
-        self.auth_handler.auth_gssapi_with_mic(
-            username, gss_host, gss_deleg_creds, my_event
-        )
-        return self.auth_handler.wait_for_response(my_event)
-
-    def auth_gssapi_keyex(self, username):
-        """
-        Authenticate to the server with GSS-API/SSPI if GSS-API kex is in use.
-
-        :param str username: The username to authenticate as.
-        :returns:
-            a list of auth types permissible for the next stage of
-            authentication (normally empty)
-        :raises: `.BadAuthenticationType` --
-            if GSS-API Key Exchange was not performed (and no event was passed
-            in)
-        :raises: `.AuthenticationException` --
-            if the authentication failed (and no event was passed in)
-        :raises: `.SSHException` -- if there was a network error
-        """
-        if (not self.active) or (not self.initial_kex_done):
-            # we should never try to authenticate unless we're on a secure link
-            raise SSHException("No existing session")
-        my_event = threading.Event()
-        self.auth_handler = AuthHandler(self)
-        self.auth_handler.auth_gssapi_keyex(username, my_event)
-        return self.auth_handler.wait_for_response(my_event)
-
     def set_log_channel(self, name):
         """
         Set the channel for this transport's logging.  The default is
@@ -1802,7 +1639,7 @@ class Transport(threading.Thread, ClosingContextManager):
     def stop_thread(self):
         self.active = False
         self.packetizer.close()
-        if PY2:
+        if False:
             # Original join logic; #520 doesn't appear commonly present under
             # Python 2.
             while self.is_alive() and self is not threading.current_thread():
@@ -1909,7 +1746,7 @@ class Transport(threading.Thread, ClosingContextManager):
         m = Message()
         m.add_mpint(self.K)
         m.add_bytes(self.H)
-        m.add_byte(b(id))
+        m.add_byte(id.encode("utf8"))
         m.add_bytes(self.session_id)
         # Fallback to SHA1 for kex engines that fail to specify a hex
         # algorithm, or for e.g. transport tests that don't run kexinit.
@@ -2044,7 +1881,7 @@ class Transport(threading.Thread, ClosingContextManager):
             self._log(DEBUG, "starting thread (client mode): {}".format(tid))
         try:
             try:
-                self.packetizer.write_all(b(self.local_version + "\r\n"))
+                self.packetizer.write_all((self.local_version + "\r\n").encode("utf8"))
                 self._log(
                     DEBUG,
                     "Local version/idstring: {}".format(self.local_version),
@@ -2264,7 +2101,6 @@ class Transport(threading.Thread, ClosingContextManager):
             self.clear_to_send.clear()
         finally:
             self.clear_to_send_lock.release()
-        self.gss_kex_used = False
         self.in_kex = True
         if self.server_mode:
             mp_required_prefix = "diffie-hellman-group-exchange-sha"