Blacken Paramiko on 2.4

1 files changed, 167 insertions, 124 deletions

diff --git a/paramiko/auth_handler.py b/paramiko/auth_handler.py
index a1ce5e3b..416657e2 100644
--- a/paramiko/auth_handler.py
+++ b/paramiko/auth_handler.py
@@ -24,31 +24,55 @@ import weakref
 import time
 
 from paramiko.common import (
-    cMSG_SERVICE_REQUEST, cMSG_DISCONNECT, DISCONNECT_SERVICE_NOT_AVAILABLE,
-    DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE, cMSG_USERAUTH_REQUEST,
-    cMSG_SERVICE_ACCEPT, DEBUG, AUTH_SUCCESSFUL, INFO, cMSG_USERAUTH_SUCCESS,
-    cMSG_USERAUTH_FAILURE, AUTH_PARTIALLY_SUCCESSFUL,
-    cMSG_USERAUTH_INFO_REQUEST, WARNING, AUTH_FAILED, cMSG_USERAUTH_PK_OK,
-    cMSG_USERAUTH_INFO_RESPONSE, MSG_SERVICE_REQUEST, MSG_SERVICE_ACCEPT,
-    MSG_USERAUTH_REQUEST, MSG_USERAUTH_SUCCESS, MSG_USERAUTH_FAILURE,
-    MSG_USERAUTH_BANNER, MSG_USERAUTH_INFO_REQUEST, MSG_USERAUTH_INFO_RESPONSE,
-    cMSG_USERAUTH_GSSAPI_RESPONSE, cMSG_USERAUTH_GSSAPI_TOKEN,
-    cMSG_USERAUTH_GSSAPI_MIC, MSG_USERAUTH_GSSAPI_RESPONSE,
-    MSG_USERAUTH_GSSAPI_TOKEN, MSG_USERAUTH_GSSAPI_ERROR,
-    MSG_USERAUTH_GSSAPI_ERRTOK, MSG_USERAUTH_GSSAPI_MIC, MSG_NAMES,
-    cMSG_USERAUTH_BANNER
+    cMSG_SERVICE_REQUEST,
+    cMSG_DISCONNECT,
+    DISCONNECT_SERVICE_NOT_AVAILABLE,
+    DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
+    cMSG_USERAUTH_REQUEST,
+    cMSG_SERVICE_ACCEPT,
+    DEBUG,
+    AUTH_SUCCESSFUL,
+    INFO,
+    cMSG_USERAUTH_SUCCESS,
+    cMSG_USERAUTH_FAILURE,
+    AUTH_PARTIALLY_SUCCESSFUL,
+    cMSG_USERAUTH_INFO_REQUEST,
+    WARNING,
+    AUTH_FAILED,
+    cMSG_USERAUTH_PK_OK,
+    cMSG_USERAUTH_INFO_RESPONSE,
+    MSG_SERVICE_REQUEST,
+    MSG_SERVICE_ACCEPT,
+    MSG_USERAUTH_REQUEST,
+    MSG_USERAUTH_SUCCESS,
+    MSG_USERAUTH_FAILURE,
+    MSG_USERAUTH_BANNER,
+    MSG_USERAUTH_INFO_REQUEST,
+    MSG_USERAUTH_INFO_RESPONSE,
+    cMSG_USERAUTH_GSSAPI_RESPONSE,
+    cMSG_USERAUTH_GSSAPI_TOKEN,
+    cMSG_USERAUTH_GSSAPI_MIC,
+    MSG_USERAUTH_GSSAPI_RESPONSE,
+    MSG_USERAUTH_GSSAPI_TOKEN,
+    MSG_USERAUTH_GSSAPI_ERROR,
+    MSG_USERAUTH_GSSAPI_ERRTOK,
+    MSG_USERAUTH_GSSAPI_MIC,
+    MSG_NAMES,
+    cMSG_USERAUTH_BANNER,
 )
 from paramiko.message import Message
 from paramiko.py3compat import bytestring
 from paramiko.ssh_exception import (
-    SSHException, AuthenticationException, BadAuthenticationType,
+    SSHException,
+    AuthenticationException,
+    BadAuthenticationType,
     PartialAuthentication,
 )
 from paramiko.server import InteractiveQuery
 from paramiko.ssh_gss import GSSAuth, GSS_EXCEPTIONS
 
 
-class AuthHandler (object):
+class AuthHandler(object):
     """
     Internal class to handle the mechanics of authentication.
     """
@@ -58,7 +82,7 @@ class AuthHandler (object):
         self.username = None
         self.authenticated = False
         self.auth_event = None
-        self.auth_method = ''
+        self.auth_method = ""
         self.banner = None
         self.password = None
         self.private_key = None
@@ -87,7 +111,7 @@ class AuthHandler (object):
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'none'
+            self.auth_method = "none"
             self.username = username
             self._request_auth()
         finally:
@@ -97,7 +121,7 @@ class AuthHandler (object):
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'publickey'
+            self.auth_method = "publickey"
             self.username = username
             self.private_key = key
             self._request_auth()
@@ -108,21 +132,21 @@ class AuthHandler (object):
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'password'
+            self.auth_method = "password"
             self.username = username
             self.password = password
             self._request_auth()
         finally:
             self.transport.lock.release()
 
-    def auth_interactive(self, username, handler, event, submethods=''):
+    def auth_interactive(self, username, handler, event, submethods=""):
         """
         response_list = handler(title, instructions, prompt_list)
         """
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'keyboard-interactive'
+            self.auth_method = "keyboard-interactive"
             self.username = username
             self.interactive_handler = handler
             self.submethods = submethods
@@ -134,7 +158,7 @@ class AuthHandler (object):
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'gssapi-with-mic'
+            self.auth_method = "gssapi-with-mic"
             self.username = username
             self.gss_host = gss_host
             self.gss_deleg_creds = gss_deleg_creds
@@ -146,7 +170,7 @@ class AuthHandler (object):
         self.transport.lock.acquire()
         try:
             self.auth_event = event
-            self.auth_method = 'gssapi-keyex'
+            self.auth_method = "gssapi-keyex"
             self.username = username
             self._request_auth()
         finally:
@@ -161,15 +185,15 @@ class AuthHandler (object):
     def _request_auth(self):
         m = Message()
         m.add_byte(cMSG_SERVICE_REQUEST)
-        m.add_string('ssh-userauth')
+        m.add_string("ssh-userauth")
         self.transport._send_message(m)
 
     def _disconnect_service_not_available(self):
         m = Message()
         m.add_byte(cMSG_DISCONNECT)
         m.add_int(DISCONNECT_SERVICE_NOT_AVAILABLE)
-        m.add_string('Service not available')
-        m.add_string('en')
+        m.add_string("Service not available")
+        m.add_string("en")
         self.transport._send_message(m)
         self.transport.close()
 
@@ -177,8 +201,8 @@ class AuthHandler (object):
         m = Message()
         m.add_byte(cMSG_DISCONNECT)
         m.add_int(DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE)
-        m.add_string('No more auth methods available')
-        m.add_string('en')
+        m.add_string("No more auth methods available")
+        m.add_string("en")
         self.transport._send_message(m)
         self.transport.close()
 
@@ -188,7 +212,7 @@ class AuthHandler (object):
         m.add_byte(cMSG_USERAUTH_REQUEST)
         m.add_string(username)
         m.add_string(service)
-        m.add_string('publickey')
+        m.add_string("publickey")
         m.add_boolean(True)
         # Use certificate contents, if available, plain pubkey otherwise
         if key.public_blob:
@@ -208,17 +232,17 @@ class AuthHandler (object):
             if not self.transport.is_active():
                 e = self.transport.get_exception()
                 if (e is None) or issubclass(e.__class__, EOFError):
-                    e = AuthenticationException('Authentication failed.')
+                    e = AuthenticationException("Authentication failed.")
                 raise e
             if event.is_set():
                 break
             if max_ts is not None and max_ts <= time.time():
-                raise AuthenticationException('Authentication timeout.')
+                raise AuthenticationException("Authentication timeout.")
 
         if not self.is_authenticated():
             e = self.transport.get_exception()
             if e is None:
-                e = AuthenticationException('Authentication failed.')
+                e = AuthenticationException("Authentication failed.")
             # this is horrible.  Python Exception isn't yet descended from
             # object, so type(e) won't work. :(
             if issubclass(e.__class__, PartialAuthentication):
@@ -228,7 +252,7 @@ class AuthHandler (object):
 
     def _parse_service_request(self, m):
         service = m.get_text()
-        if self.transport.server_mode and (service == 'ssh-userauth'):
+        if self.transport.server_mode and (service == "ssh-userauth"):
             # accepted
             m = Message()
             m.add_byte(cMSG_SERVICE_ACCEPT)
@@ -247,18 +271,18 @@ class AuthHandler (object):
 
     def _parse_service_accept(self, m):
         service = m.get_text()
-        if service == 'ssh-userauth':
-            self._log(DEBUG, 'userauth is OK')
+        if service == "ssh-userauth":
+            self._log(DEBUG, "userauth is OK")
             m = Message()
             m.add_byte(cMSG_USERAUTH_REQUEST)
             m.add_string(self.username)
-            m.add_string('ssh-connection')
+            m.add_string("ssh-connection")
             m.add_string(self.auth_method)
-            if self.auth_method == 'password':
+            if self.auth_method == "password":
                 m.add_boolean(False)
                 password = bytestring(self.password)
                 m.add_string(password)
-            elif self.auth_method == 'publickey':
+            elif self.auth_method == "publickey":
                 m.add_boolean(True)
                 # Use certificate contents, if available, plain pubkey
                 # otherwise
@@ -269,11 +293,12 @@ class AuthHandler (object):
                     m.add_string(self.private_key.get_name())
                     m.add_string(self.private_key)
                 blob = self._get_session_blob(
-                    self.private_key, 'ssh-connection', self.username)
+                    self.private_key, "ssh-connection", self.username
+                )
                 sig = self.private_key.sign_ssh_data(blob)
                 m.add_string(sig)
-            elif self.auth_method == 'keyboard-interactive':
-                m.add_string('')
+            elif self.auth_method == "keyboard-interactive":
+                m.add_string("")
                 m.add_string(self.submethods)
             elif self.auth_method == "gssapi-with-mic":
                 sshgss = GSSAuth(self.auth_method, self.gss_deleg_creds)
@@ -292,10 +317,11 @@ class AuthHandler (object):
                     m = Message()
                     m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                     try:
-                        m.add_string(sshgss.ssh_init_sec_context(
-                            self.gss_host,
-                            mech,
-                            self.username,))
+                        m.add_string(
+                            sshgss.ssh_init_sec_context(
+                                self.gss_host, mech, self.username
+                            )
+                        )
                     except GSS_EXCEPTIONS as e:
                         return self._handle_local_gss_failure(e)
                     self.transport._send_message(m)
@@ -308,7 +334,8 @@ class AuthHandler (object):
                                     self.gss_host,
                                     mech,
                                     self.username,
-                                    srv_token)
+                                    srv_token,
+                                )
                             except GSS_EXCEPTIONS as e:
                                 return self._handle_local_gss_failure(e)
                             # After this step the GSSAPI should not return any
@@ -340,48 +367,55 @@ class AuthHandler (object):
                     min_status = m.get_int()
                     err_msg = m.get_string()
                     m.get_string()  # Lang tag - discarded
-                    raise SSHException("""GSS-API Error:
+                    raise SSHException(
+                        """GSS-API Error:
 Major Status: {}
 Minor Status: {}
 Error Message: {}
-""".format(maj_status, min_status, err_msg))
+""".format(
+                            maj_status, min_status, err_msg
+                        )
+                    )
                 elif ptype == MSG_USERAUTH_FAILURE:
                     self._parse_userauth_failure(m)
                     return
                 else:
                     raise SSHException(
-                        "Received Package: {}".format(MSG_NAMES[ptype]))
+                        "Received Package: {}".format(MSG_NAMES[ptype])
+                    )
             elif (
-                self.auth_method == 'gssapi-keyex' and
-                self.transport.gss_kex_used
+                self.auth_method == "gssapi-keyex"
+                and self.transport.gss_kex_used
             ):
                 kexgss = self.transport.kexgss_ctxt
                 kexgss.set_username(self.username)
                 mic_token = kexgss.ssh_get_mic(self.transport.session_id)
                 m.add_string(mic_token)
-            elif self.auth_method == 'none':
+            elif self.auth_method == "none":
                 pass
             else:
                 raise SSHException(
-                    'Unknown auth method "{}"'.format(self.auth_method))
+                    'Unknown auth method "{}"'.format(self.auth_method)
+                )
             self.transport._send_message(m)
         else:
             self._log(
-                DEBUG,
-                'Service request "{}" accepted (?)'.format(service))
+                DEBUG, 'Service request "{}" accepted (?)'.format(service)
+            )
 
     def _send_auth_result(self, username, method, result):
         # okay, send result
         m = Message()
         if result == AUTH_SUCCESSFUL:
-            self._log(INFO, 'Auth granted ({}).'.format(method))
+            self._log(INFO, "Auth granted ({}).".format(method))
             m.add_byte(cMSG_USERAUTH_SUCCESS)
             self.authenticated = True
         else:
-            self._log(INFO, 'Auth rejected ({}).'.format(method))
+            self._log(INFO, "Auth rejected ({}).".format(method))
             m.add_byte(cMSG_USERAUTH_FAILURE)
             m.add_string(
-                self.transport.server_object.get_allowed_auths(username))
+                self.transport.server_object.get_allowed_auths(username)
+            )
             if result == AUTH_PARTIALLY_SUCCESSFUL:
                 m.add_boolean(True)
             else:
@@ -411,7 +445,7 @@ Error Message: {}
             # er, uh... what?
             m = Message()
             m.add_byte(cMSG_USERAUTH_FAILURE)
-            m.add_string('none')
+            m.add_string("none")
             m.add_boolean(False)
             self.transport._send_message(m)
             return
@@ -423,18 +457,20 @@ Error Message: {}
         method = m.get_text()
         self._log(
             DEBUG,
-            'Auth request (type={}) service={}, username={}'.format(
+            "Auth request (type={}) service={}, username={}".format(
                 method, service, username
-            )
+            ),
         )
-        if service != 'ssh-connection':
+        if service != "ssh-connection":
             self._disconnect_service_not_available()
             return
-        if ((self.auth_username is not None) and
-                (self.auth_username != username)):
+        if (
+            (self.auth_username is not None)
+            and (self.auth_username != username)
+        ):
             self._log(
                 WARNING,
-                'Auth rejected because the client attempted to change username in mid-flight'  # noqa
+                "Auth rejected because the client attempted to change username in mid-flight",  # noqa
             )
             self._disconnect_no_more_auth()
             return
@@ -442,13 +478,13 @@ Error Message: {}
         # check if GSS-API authentication is enabled
         gss_auth = self.transport.server_object.enable_auth_gssapi()
 
-        if method == 'none':
+        if method == "none":
             result = self.transport.server_object.check_auth_none(username)
-        elif method == 'password':
+        elif method == "password":
             changereq = m.get_boolean()
             password = m.get_binary()
             try:
-                password = password.decode('UTF-8')
+                password = password.decode("UTF-8")
             except UnicodeError:
                 # some clients/servers expect non-utf-8 passwords!
                 # in this case, just return the raw byte string.
@@ -457,31 +493,28 @@ Error Message: {}
                 # always treated as failure, since we don't support changing
                 # passwords, but collect the list of valid auth types from
                 # the callback anyway
-                self._log(
-                    DEBUG,
-                    'Auth request to change passwords (rejected)')
+                self._log(DEBUG, "Auth request to change passwords (rejected)")
                 newpassword = m.get_binary()
                 try:
-                    newpassword = newpassword.decode('UTF-8', 'replace')
+                    newpassword = newpassword.decode("UTF-8", "replace")
                 except UnicodeError:
                     pass
                 result = AUTH_FAILED
             else:
                 result = self.transport.server_object.check_auth_password(
-                    username, password)
-        elif method == 'publickey':
+                    username, password
+                )
+        elif method == "publickey":
             sig_attached = m.get_boolean()
             keytype = m.get_text()
             keyblob = m.get_binary()
             try:
                 key = self.transport._key_info[keytype](Message(keyblob))
             except SSHException as e:
-                self._log(
-                    INFO,
-                    'Auth rejected: public key: {}'.format(str(e)))
+                self._log(INFO, "Auth rejected: public key: {}".format(str(e)))
                 key = None
             except Exception as e:
-                msg = 'Auth rejected: unsupported or mangled public key ({}: {})' # noqa
+                msg = "Auth rejected: unsupported or mangled public key ({}: {})"  # noqa
                 self._log(INFO, msg.format(e.__class__.__name__, e))
                 key = None
             if key is None:
@@ -489,7 +522,8 @@ Error Message: {}
                 return
             # first check if this key is okay... if not, we can skip the verify
             result = self.transport.server_object.check_auth_publickey(
-                username, key)
+                username, key
+            )
             if result != AUTH_FAILED:
                 # key is okay, verify it
                 if not sig_attached:
@@ -504,14 +538,13 @@ Error Message: {}
                 sig = Message(m.get_binary())
                 blob = self._get_session_blob(key, service, username)
                 if not key.verify_ssh_sig(blob, sig):
-                    self._log(
-                        INFO,
-                        'Auth rejected: invalid signature')
+                    self._log(INFO, "Auth rejected: invalid signature")
                     result = AUTH_FAILED
-        elif method == 'keyboard-interactive':
+        elif method == "keyboard-interactive":
             submethods = m.get_string()
             result = self.transport.server_object.check_auth_interactive(
-                username, submethods)
+                username, submethods
+            )
             if isinstance(result, InteractiveQuery):
                 # make interactive query instead of response
                 self._interactive_query(result)
@@ -527,7 +560,8 @@ Error Message: {}
             if mechs > 1:
                 self._log(
                     INFO,
-                    'Disconnect: Received more than one GSS-API OID mechanism')
+                    "Disconnect: Received more than one GSS-API OID mechanism",
+                )
                 self._disconnect_no_more_auth()
             desired_mech = m.get_string()
             mech_ok = sshgss.ssh_check_mech(desired_mech)
@@ -535,7 +569,8 @@ Error Message: {}
             if not mech_ok:
                 self._log(
                     INFO,
-                    'Disconnect: Received an invalid GSS-API OID mechanism')
+                    "Disconnect: Received an invalid GSS-API OID mechanism",
+                )
                 self._disconnect_no_more_auth()
             # send the Kerberos V5 GSSAPI OID to the client
             supported_mech = sshgss.ssh_gss_oids("server")
@@ -544,11 +579,14 @@ Error Message: {}
             m = Message()
             m.add_byte(cMSG_USERAUTH_GSSAPI_RESPONSE)
             m.add_bytes(supported_mech)
-            self.transport.auth_handler = GssapiWithMicAuthHandler(self,
-                                                                   sshgss)
-            self.transport._expected_packet = (MSG_USERAUTH_GSSAPI_TOKEN,
-                                               MSG_USERAUTH_REQUEST,
-                                               MSG_SERVICE_REQUEST)
+            self.transport.auth_handler = GssapiWithMicAuthHandler(
+                self, sshgss
+            )
+            self.transport._expected_packet = (
+                MSG_USERAUTH_GSSAPI_TOKEN,
+                MSG_USERAUTH_REQUEST,
+                MSG_SERVICE_REQUEST,
+            )
             self.transport._send_message(m)
             return
         elif method == "gssapi-keyex" and gss_auth:
@@ -559,16 +597,17 @@ Error Message: {}
                 result = AUTH_FAILED
                 self._send_auth_result(username, method, result)
             try:
-                sshgss.ssh_check_mic(mic_token,
-                                     self.transport.session_id,
-                                     self.auth_username)
+                sshgss.ssh_check_mic(
+                    mic_token, self.transport.session_id, self.auth_username
+                )
             except Exception:
                 result = AUTH_FAILED
                 self._send_auth_result(username, method, result)
                 raise
             result = AUTH_SUCCESSFUL
             self.transport.server_object.check_auth_gssapi_keyex(
-                username, result)
+                username, result
+            )
         else:
             result = self.transport.server_object.check_auth_none(username)
         # okay, send result
@@ -576,8 +615,8 @@ Error Message: {}
 
     def _parse_userauth_success(self, m):
         self._log(
-            INFO,
-            'Authentication ({}) successful!'.format(self.auth_method))
+            INFO, "Authentication ({}) successful!".format(self.auth_method)
+        )
         self.authenticated = True
         self.transport._auth_trigger()
         if self.auth_event is not None:
@@ -587,24 +626,23 @@ Error Message: {}
         authlist = m.get_list()
         partial = m.get_boolean()
         if partial:
-            self._log(INFO, 'Authentication continues...')
-            self._log(DEBUG, 'Methods: ' + str(authlist))
+            self._log(INFO, "Authentication continues...")
+            self._log(DEBUG, "Methods: " + str(authlist))
             self.transport.saved_exception = PartialAuthentication(authlist)
         elif self.auth_method not in authlist:
             for msg in (
-                'Authentication type ({}) not permitted.'.format(
+                "Authentication type ({}) not permitted.".format(
                     self.auth_method
                 ),
-                'Allowed methods: {}'.format(authlist),
+                "Allowed methods: {}".format(authlist),
             ):
                 self._log(DEBUG, msg)
             self.transport.saved_exception = BadAuthenticationType(
-                'Bad authentication type', authlist
+                "Bad authentication type", authlist
             )
         else:
             self._log(
-                INFO,
-                'Authentication ({}) failed.'.format(self.auth_method)
+                INFO, "Authentication ({}) failed.".format(self.auth_method)
             )
         self.authenticated = False
         self.username = None
@@ -614,12 +652,12 @@ Error Message: {}
     def _parse_userauth_banner(self, m):
         banner = m.get_string()
         self.banner = banner
-        self._log(INFO, 'Auth banner: {}'.format(banner))
+        self._log(INFO, "Auth banner: {}".format(banner))
         # who cares.
 
     def _parse_userauth_info_request(self, m):
-        if self.auth_method != 'keyboard-interactive':
-            raise SSHException('Illegal info request from server')
+        if self.auth_method != "keyboard-interactive":
+            raise SSHException("Illegal info request from server")
         title = m.get_text()
         instructions = m.get_text()
         m.get_binary()  # lang
@@ -628,7 +666,8 @@ Error Message: {}
         for i in range(prompts):
             prompt_list.append((m.get_text(), m.get_boolean()))
         response_list = self.interactive_handler(
-            title, instructions, prompt_list)
+            title, instructions, prompt_list
+        )
 
         m = Message()
         m.add_byte(cMSG_USERAUTH_INFO_RESPONSE)
@@ -639,25 +678,26 @@ Error Message: {}
 
     def _parse_userauth_info_response(self, m):
         if not self.transport.server_mode:
-            raise SSHException('Illegal info response from server')
+            raise SSHException("Illegal info response from server")
         n = m.get_int()
         responses = []
         for i in range(n):
             responses.append(m.get_text())
         result = self.transport.server_object.check_auth_interactive_response(
-            responses)
+            responses
+        )
         if isinstance(result, InteractiveQuery):
             # make interactive query instead of response
             self._interactive_query(result)
             return
         self._send_auth_result(
-            self.auth_username, 'keyboard-interactive', result)
+            self.auth_username, "keyboard-interactive", result
+        )
 
     def _handle_local_gss_failure(self, e):
         self.transport.saved_exception = e
         self._log(DEBUG, "GSSAPI failure: {}".format(e))
-        self._log(INFO, 'Authentication ({}) failed.'.format(
-            self.auth_method))
+        self._log(INFO, "Authentication ({}) failed.".format(self.auth_method))
         self.authenticated = False
         self.username = None
         if self.auth_event is not None:
@@ -718,9 +758,9 @@ class GssapiWithMicAuthHandler(object):
         # context.
         sshgss = self.sshgss
         try:
-            token = sshgss.ssh_accept_sec_context(self.gss_host,
-                                                  client_token,
-                                                  self.auth_username)
+            token = sshgss.ssh_accept_sec_context(
+                self.gss_host, client_token, self.auth_username
+            )
         except Exception as e:
             self.transport.saved_exception = e
             result = AUTH_FAILED
@@ -731,9 +771,11 @@ class GssapiWithMicAuthHandler(object):
             m = Message()
             m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
             m.add_string(token)
-            self.transport._expected_packet = (MSG_USERAUTH_GSSAPI_TOKEN,
-                                               MSG_USERAUTH_GSSAPI_MIC,
-                                               MSG_USERAUTH_REQUEST)
+            self.transport._expected_packet = (
+                MSG_USERAUTH_GSSAPI_TOKEN,
+                MSG_USERAUTH_GSSAPI_MIC,
+                MSG_USERAUTH_REQUEST,
+            )
             self.transport._send_message(m)
 
     def _parse_userauth_gssapi_mic(self, m):
@@ -742,9 +784,9 @@ class GssapiWithMicAuthHandler(object):
         username = self.auth_username
         self._restore_delegate_auth_handler()
         try:
-            sshgss.ssh_check_mic(mic_token,
-                                 self.transport.session_id,
-                                 username)
+            sshgss.ssh_check_mic(
+                mic_token, self.transport.session_id, username
+            )
         except Exception as e:
             self.transport.saved_exception = e
             result = AUTH_FAILED
@@ -754,8 +796,9 @@ class GssapiWithMicAuthHandler(object):
         # The OpenSSH server is able to create a TGT with the delegated
         # client credentials, but this is not supported by GSS-API.
         result = AUTH_SUCCESSFUL
-        self.transport.server_object.check_auth_gssapi_with_mic(username,
-                                                                result)
+        self.transport.server_object.check_auth_gssapi_with_mic(
+            username, result
+        )
         # okay, send result
         self._send_auth_result(username, self.method, result)