Problème de connexion implicite TLS Python FTP

j'ai travaillé sur le même problème pour une demi-journée et finalement pensé à elle.

pour le TLS/SSL FTP implicite (defualt port 990), notre programme client doit construire une connexion TLS/SSL immédiatement après la création de la socket. Mais la classe de python FTP_TLS ne recharge pas la se connecter fonction à partir de la classe FTP. Nous avons besoin pour résoudre le problème:

class tyFTP(ftplib.FTP_TLS):
  def __init__(self,
               host='',
               user='',
               passwd='',
               acct='',
               keyfile=None,
               certfile=None,
               timeout=60):

    ftplib.FTP_TLS.__init__(self,
                            host=host,
                            user=user,
                            passwd=passwd,
                            acct=acct,
                            keyfile=keyfile,
                            certfile=certfile,
                            timeout=timeout)

  def connect(self, host='', port=0, timeout=-999):
    """Connect to host.  Arguments are:
    - host: hostname to connect to (string, default previous host)
    - port: port to connect to (integer, default previous port)
    """
    if host != '':
        self.host = host
    if port > 0:
        self.port = port
    if timeout != -999:
        self.timeout = timeout
    try:
        self.sock = socket.create_connection((self.host, self.port), self.timeout)
        self.af = self.sock.family
        # add this line!!!
        self.sock = ssl.wrap_socket(self.sock,
                                    self.keyfile,
                                    self.certfile,
                                    ssl_version=ssl.PROTOCOL_TLSv1)
        # add end
        self.file = self.sock.makefile('rb')
        self.welcome = self.getresp()
    except Exception as e:
        print(e)
    return self.welcome

cette classe dérivée recharge le se connecter fonction et construit un wrapper autour de la socket à TLS. Après vous connectez-vous et connectez-vous au serveur FTP, vous devez appeler: FTP_TLS.prot_p() avant d'exécuter une commande FTP!

Espérons que cela va aider ^_^

extension de la réponse de NERV - ce qui m'a énormément aidé, voici comment j'ai pu résoudre mon problème avec une connexion TLS implicite sur le port 990 nécessitant une authentification.

from ftplib import FTP_TLS
import socket
import ssl

class tyFTP(FTP_TLS):
    def __init__(self, host='', user='', passwd='', acct='', keyfile=None, certfile=None, timeout=60):
        FTP_TLS.__init__(self, host, user, passwd, acct, keyfile, certfile, timeout)
    def connect(self, host='', port=0, timeout=-999):
        if host != '':
            self.host = host
        if port > 0:
            self.port = port
        if timeout != -999:
            self.timeout = timeout

        try: 
            self.sock = socket.create_connection((self.host, self.port), self.timeout)
            self.af = self.sock.family
            self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile, ssl_version=ssl.PROTOCOL_TLSv1)
            self.file = self.sock.makefile('rb')
            self.welcome = self.getresp()
        except Exception as e:
            print e
        return self.welcome

puis à partir de mon application principale j'ai fait ceci:

from ImplicityTLS import tyFTP
server = tyFTP()
server.connect(host="xxxxx", port=990)
server.login(user="yyyy", passwd="fffff")
server.prot_p()

et c'est tout, j'ai pu télécharger des fichiers, etc. Les accessoires vont à NERV pour la réponse originale.

pour étendre les solutions qui ont été proposées jusqu'à présent, le problème est que les connexions FTPS implicites ont besoin que la socket soit enveloppée ssl automatiquement, avant que nous ayons la chance d'appeler login(). Beaucoup de sous-classes que les gens proposent font cela dans le contexte de la méthode connect, nous pouvons plus généralement gérer cela en modifiant le get/set of self.chaussette avec une propriété auto-wrap sur le plateau:

import ftplib
import ssl

class ImplicitFTP_TLS(ftplib.FTP_TLS):
    """FTP_TLS subclass that automatically wraps sockets in SSL to support implicit FTPS."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._sock = None

    @property
    def sock(self):
        """Return the socket."""
        return self._sock

    @sock.setter
    def sock(self, value):
        """When modifying the socket, ensure that it is ssl wrapped."""
        if value is not None and not isinstance(value, ssl.SSLSocket):
            value = self.context.wrap_socket(value)
        self._sock = value

L'utilisation est essentiellement la même qu'avec la norme FTP_TLS classe:

ftp_client = ImplicitFTP_TLS()
ftp_client.connect(host='ftp.example.com', port=990)
ftp_client.login(user='USERNAME', passwd='PASSWORD')
ftp_client.prot_p()

la réponse de NERV et L'échantillon de Brad Decker ont été très utiles. Bravo à eux. Ils m'a sauvé heures.

dans mon cas, la connexion a fonctionné une fois que j'ai enlevé le ssl_version paramètre de ssl.wrap_socket méthode. Aussi, pour envoyer une commande au serveur, j'ai dû remplacer le ntransfercmd méthode de l' FTP_TLS classe et de supprimer le ssl_version paramètre.

C'est le code qui a fonctionné pour moi:

from ftplib import FTP_TLS, FTP
import socket
import ssl

class IMPLICIT_FTP_TLS(FTP_TLS):
    def __init__(self, host='', user='', passwd='', acct='', keyfile=None,
        certfile=None, timeout=60):
        FTP_TLS.__init__(self, host, user, passwd, acct, keyfile, certfile, timeout)

    def connect(self, host='', port=0, timeout=-999):
        '''Connect to host.  Arguments are:
        - host: hostname to connect to (string, default previous host)
        - port: port to connect to (integer, default previous port)
        '''
        if host != '':
            self.host = host
        if port > 0:
            self.port = port
        if timeout != -999:
            self.timeout = timeout
        try:
            self.sock = socket.create_connection((self.host, self.port), self.timeout)
            self.af = self.sock.family
            self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile)
            self.file = self.sock.makefile('rb')
            self.welcome = self.getresp()
        except Exception as e:
            print (e)
        return self.welcome

    def ntransfercmd(self, cmd, rest=None):
        conn, size = FTP.ntransfercmd(self, cmd, rest)
        if self._prot_p:
            conn = ssl.wrap_socket(conn, self.keyfile, self.certfile)
        return conn, size

et l'échantillon obligatoire:

>>> ftps = IMPLICIT_FTP_TLS()
>>> ftps.connect(host='your.ftp.host', port=990)
>>> ftps.login(user="your_user", passwd="your_passwd")
>>> ftps.prot_p()
>>> ftps.retrlines('LIST')

je sais que ce fil est assez ancien et ftp n'est pas aussi populaire qu'il l'était autrefois, mais de toute façon, au cas où il aide quelqu'un que je voudrais faire une contribution supplémentaire. J'ai rencontré une situation similaire en essayant de me connecter au serveur ftp en utilisant implicitement (Port 990) ftps en mode passif. Dans ce cas, le serveur, après négociation de la connexion initiale, fournit habituellement une nouvelle adresse IP hôte et un nouveau port, probablement différents de ceux qui ont été utilisés pour faire la connexion initiale, sur lesquels la réels transferts de données sont censés se produire. Aucun problème, les clients ftps, y compris python, peuvent gérer cela, seulement ce serveur particulier fournissait une adresse IP non-routable (probablement interne au pare-feu). J'ai remarqué que FileZilla s'est connecté sans problème, mais Python ftplib ne pouvait pas. Puis je suis tombé sur ce fil:

comment remplacer une adresse IP non routable par une adresse serveur sur ftplib

ce qui m'a mis dans le coup. Utilisation de la méthodologie Grzegorz Wierzowiecki J'ai étendu la méthode à laquelle fait allusion dans ce fil et est venu avec ceci, qui a résolu mon problème.

import ftplib, os, sys
import socket
import ssl
FTPS_OBJ = ftplib.FTP_TLS



def conn_i_ftps(FTP_Site, Login_Name, Login_Password):
    print "Starting IMPLICIT ftp_tls..."
    ftps = tyFTP()
    print ftps.connect(host=FTP_Site, port=990, timeout=120)
    ftps.prot_p()
    ftps.login(user=Login_Name, passwd=Login_Password)
    print "Logged In"
    ftps.retrlines('LIST')
    # return ftps


class tyFTP(FTPS_OBJ):
    def __init__(self, host='', user='', passwd='', acct='', keyfile=None, certfile=None, timeout=60):
        FTPS_OBJ.__init__(self, host, user, passwd, acct, keyfile, certfile, timeout)

    def connect(self, host='', port=0, timeout=-999):
        if host != '':
            self.host = host
        if port > 0:
            self.port = port
        if timeout != -999:
            self.timeout = timeout

        try:
            self.sock = socket.create_connection((self.host, self.port), self.timeout)
            self.af = self.sock.family
            self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile)
            self.file = self.sock.makefile('rb')
            self.welcome = self.getresp()
        except Exception as e:
            print e
        return self.welcome

    def makepasv(self):
        print port #<---Show passively assigned port
        print host #<---Show the non-routable, passively assigned IP
        host, port = FTPS_OBJ.makepasv(self)
        host = socket.gethostbyname(self.host) #<---- This changes the host back to the original IP that was used for the connection
        print 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
        print host #<----Showing the original IP
        return host, port

Puis le code est appelé comme ceci

FTP_Site       =  "ftp.someserver.com"
Login_Name     =  "some_name"
Login_Password =  "some_passwd"

conn_i_ftps(FTP_Site, Login_Name, Login_Password)

je suppose que l'on peut envelopper les lignes où l'hôte est changé de nouveau avec une instruction IF identifiant des adresses non-routables, comme ceci:

if host.split(".")[0] in (10, 192, 172):
     host = socket.gethostbyname(self.host)
     .
     .
     .