Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1
    Membre du Club
    Profil pro Patrick
    Inscrit en
    juin 2010
    Messages
    419
    Détails du profil
    Informations personnelles :
    Nom : Patrick
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : juin 2010
    Messages : 419
    Points : 56
    Points
    56

    Par défaut Erreur "new key" ssh paramiko

    Bonjour à tous,

    Voilà depuis quelques temps j'ai un script qui se connecte sur un serveur ssh et qui télécharge des fichiers. Le script marchait très bien pendant un mois environ. Mais depuis quelques jours il bug. En effet il télécharge des fichiers puis d'un coup sans raison voici ce que m'affiche le log :

    DEBUG : kex algos:['diffie-hellman-group1-sha1'] server key:['ssh-dss'] client encrypt:['aes128-cbc'] server encrypt:['aes128-cbc'] client mac:['hmac-sha1'] server mac:['hmac-sha1'] client compress:['none'] server compress:['none'] client lang:[''] server lang:[''] kex follows?False
    DEBUG : Ciphers agreed: local=aes128-cbc, remote=aes128-cbc
    DEBUG : using kex diffie-hellman-group1-sha1; server key type ssh-dss; cipher: local aes128-cbc, remote aes128-cbc; mac: local hmac-sha1, remote hmac-sha1; compression: local none, remote none
    DEBUG : Switch to new keys ...
    Et ça le fait par la suite toutes les heures. Ca ce bloque à "Switch to new key" puis ça recommence. Il n'arrive donc pas à se reconnecter. Je ne comprend pas pourquoi d'un coup ça me fait ça... Car au départ il télécharge normalement des fichiers donc il arrive au début à se connecter... Mais ensuite c'est le drame

    Si vous avez une idée d'où peut provenir le problème je vous serais très reconnaissant. Merci de votre aide

  2. #2
    Membre du Club
    Profil pro Patrick
    Inscrit en
    juin 2010
    Messages
    419
    Détails du profil
    Informations personnelles :
    Nom : Patrick
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : juin 2010
    Messages : 419
    Points : 56
    Points
    56

    Par défaut

    Les "DEBUG" viennent de la classe "transport" :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    def _parse_kex_init(self, m):
            cookie = m.get_bytes(16)
            kex_algo_list = m.get_list()
            server_key_algo_list = m.get_list()
            client_encrypt_algo_list = m.get_list()
            server_encrypt_algo_list = m.get_list()
            client_mac_algo_list = m.get_list()
            server_mac_algo_list = m.get_list()
            client_compress_algo_list = m.get_list()
            server_compress_algo_list = m.get_list()
            client_lang_list = m.get_list()
            server_lang_list = m.get_list()
            kex_follows = m.get_boolean()
            unused = m.get_int()
     
            self._log(DEBUG, 'kex algos:' + str(kex_algo_list) + ' server key:' + str(server_key_algo_list) + \
                      ' client encrypt:' + str(client_encrypt_algo_list) + \
                      ' server encrypt:' + str(server_encrypt_algo_list) + \
                      ' client mac:' + str(client_mac_algo_list) + \
                      ' server mac:' + str(server_mac_algo_list) + \
                      ' client compress:' + str(client_compress_algo_list) + \
                      ' server compress:' + str(server_compress_algo_list) + \
                      ' client lang:' + str(client_lang_list) + \
                      ' server lang:' + str(server_lang_list) + \
                      ' kex follows?' + str(kex_follows))
     
            # as a server, we pick the first item in the client's list that we support.
            # as a client, we pick the first item in our list that the server supports.
            if self.server_mode:
                agreed_kex = filter(self._preferred_kex.__contains__, kex_algo_list)
            else:
                agreed_kex = filter(kex_algo_list.__contains__, self._preferred_kex)
            if len(agreed_kex) == 0:
                raise SSHException('Incompatible ssh peer (no acceptable kex algorithm)')
            self.kex_engine = self._kex_info[agreed_kex[0]](self)
     
            if self.server_mode:
                available_server_keys = filter(self.server_key_dict.keys().__contains__,
                                               self._preferred_keys)
                agreed_keys = filter(available_server_keys.__contains__, server_key_algo_list)
            else:
                agreed_keys = filter(server_key_algo_list.__contains__, self._preferred_keys)
            if len(agreed_keys) == 0:
                raise SSHException('Incompatible ssh peer (no acceptable host key)')
            self.host_key_type = agreed_keys[0]
            if self.server_mode and (self.get_server_key() is None):
                raise SSHException('Incompatible ssh peer (can\'t match requested host key type)')
     
            if self.server_mode:
                agreed_local_ciphers = filter(self._preferred_ciphers.__contains__,
                                               server_encrypt_algo_list)
                agreed_remote_ciphers = filter(self._preferred_ciphers.__contains__,
                                              client_encrypt_algo_list)
            else:
                agreed_local_ciphers = filter(client_encrypt_algo_list.__contains__,
                                              self._preferred_ciphers)
                agreed_remote_ciphers = filter(server_encrypt_algo_list.__contains__,
                                               self._preferred_ciphers)
            if (len(agreed_local_ciphers) == 0) or (len(agreed_remote_ciphers) == 0):
                raise SSHException('Incompatible ssh server (no acceptable ciphers)')
            self.local_cipher = agreed_local_ciphers[0]
            self.remote_cipher = agreed_remote_ciphers[0]
            self._log(DEBUG, 'Ciphers agreed: local=%s, remote=%s' % (self.local_cipher, self.remote_cipher))
     
            if self.server_mode:
                agreed_remote_macs = filter(self._preferred_macs.__contains__, client_mac_algo_list)
                agreed_local_macs = filter(self._preferred_macs.__contains__, server_mac_algo_list)
            else:
                agreed_local_macs = filter(client_mac_algo_list.__contains__, self._preferred_macs)
                agreed_remote_macs = filter(server_mac_algo_list.__contains__, self._preferred_macs)
            if (len(agreed_local_macs) == 0) or (len(agreed_remote_macs) == 0):
                raise SSHException('Incompatible ssh server (no acceptable macs)')
            self.local_mac = agreed_local_macs[0]
            self.remote_mac = agreed_remote_macs[0]
     
            if self.server_mode:
                agreed_remote_compression = filter(self._preferred_compression.__contains__, client_compress_algo_list)
                agreed_local_compression = filter(self._preferred_compression.__contains__, server_compress_algo_list)
            else:
                agreed_local_compression = filter(client_compress_algo_list.__contains__, self._preferred_compression)
                agreed_remote_compression = filter(server_compress_algo_list.__contains__, self._preferred_compression)
            if (len(agreed_local_compression) == 0) or (len(agreed_remote_compression) == 0):
                raise SSHException('Incompatible ssh server (no acceptable compression) %r %r %r' % (agreed_local_compression, agreed_remote_compression, self._preferred_compression))
            self.local_compression = agreed_local_compression[0]
            self.remote_compression = agreed_remote_compression[0]
     
            self._log(DEBUG, 'using kex %s; server key type %s; cipher: local %s, remote %s; mac: local %s, remote %s; compression: local %s, remote %s' %
                      (agreed_kex[0], self.host_key_type, self.local_cipher, self.remote_cipher, self.local_mac,
                       self.remote_mac, self.local_compression, self.remote_compression))
     
            # save for computing hash later...
            # now wait!  openssh has a bug (and others might too) where there are
            # actually some extra bytes (one NUL byte in openssh's case) added to
            # the end of the packet but not parsed.  turns out we need to throw
            # away those bytes because they aren't part of the hash.
            self.remote_kex_init = chr(MSG_KEXINIT) + m.get_so_far()
    Si ça peut aider

    EDIT : Je viens de remarquer qu'il coupait en fait ma connexion SSH. Cependant je traite des données sur le serveur SSH au début de mon script mais sans jamais ensuite fermer la connexion. J'ai donc une fois les données SSH traitées, fermé la connexion. En espérant que par la suite dans mon script le problème ne réapparait pas.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •