Utilización de sshtunnel - Módulo python: sshtunnel 0.1.2

import socks
import paramiko
import select
from sshtunnel import SSHTunnelForwarder




    #--------------------------------------------------------------------#
    # Ejemplo funcional para conectarse a la máquina de salto por SOCKS. #
    # remote_bind_address: Routers o switchs.                            #
    # local_bind_address: puerto local para el proxy.                    #
    # PARAMIKO usa el sock que previamente se define.                    #
    #                                                                    #
    # La función tiene en cuenta si es el msimo Asssit IT que realiza el #
    #  túnel SSH o tiene que usar SecureCRT.                             #
    #                                                                    #
    # Se distingue dos tipos de conexiones:                              #
    #                                                                    #
    # - SrvSalto: únicamente se conecta al servidor de salto.            #
    #                                                                    #
    # - SrvSaltoRemoto: Desde el servidor de salto se conecta a un       #
    #                   dispositivo.                                     #
    #                                                                    #
    #--------------------------------------------------------------------#
    def connectar(self,TipoConexion, IpRemota, Cmd):
        #Estado de iconos:
        self.lb_activity_green.setVisible(True)
        self.lb_disconected_grey.hide()
        #leeo la variable list:
        ConfigList = []
        shelfFile = shelve.open('imagenes/mydata')
        type(shelfFile)
        ConfigList = shelfFile['ConfigList']
        shelfFile.close()

        # Conexiones gestionadas por Assit IT:
        # Index13: Assit IT
        if ConfigList[13] == True:
            if TipoConexion == "srvSaltoTelnet":
                with SSHTunnelForwarder(
                    (self.devuelve_password("srvSalto1")[0], 22),
                    ssh_host_key=None,
                    ssh_pkey=None,
                    ssh_private_key_password=None,
                    ssh_username=self.devuelve_password("usuarioSrvSalto")[0],
                    ssh_password=self.devuelve_password("usuarioSrvSalto")[1],
                    mute_exceptions=True,
                    set_keepalive=15,
                    remote_bind_address=(IpRemota, 23, 'usuariotelnet', 'passwordtelnet'),
                    local_bind_address=('0.0.0.0', self.devuelve_password("lbaPort")[0])
                ) as tunnel:
                    user='usuariotelnet'
                    password ='passwordtelnet'
                    print '1 - Abriendo telnet'
                    tn = telnetlib.Telnet("127.0.0.1",self.devuelve_password("lbaPort")[0])
                    #DEBUG.
                    datadebug = tn.set_debuglevel(10)
                    print '2 - Validando username'
                    tn.read_until("username: ")
                    tn.write(user + "\n")
                    print '3 - Metiendo el pass'
                    tn.read_until("password: ")
                    tn.write(password + "\n")
                    tn.write("terminal length 0\n")
                    tn.write(Cmd)
                    #tn.write("show ver\n")
                    #tn.write("show ver | include IOS\n")
                    tn.write("\n")
                    tn.write(" exit\n")
                    #output =(tn.read_all().decode('ascii'))
                    data = tn.read_all()
                    tn.close()
                    #print tn.read_all()
                    print "Finalizada conex. devolviendo datos"
                    resolv_connectarSSH = data
                    self.textEdit_27.append(str(data))
                    self.textEdit_27.append("debug;" + str(datadebug))
                  

            # TipoConexion: srvSaltoRemoto SSH
            elif TipoConexion == "srvSaltoRemoto":
                self.textEdit_12.setText(str(self.devuelve_password("UsuarioRouter")[0]))
                self.textEdit_13.setText(str(self.devuelve_password("UsuarioRouter")[1]))
                self.textEdit_14.setText(str(self.devuelve_password("srvSalto1")[0]))
                self.textEdit_15.setText(str(self.devuelve_password("lbaPort")[0]))
                self.textEdit_16.setText("HE pasado")
                with SSHTunnelForwarder(
                    (self.devuelve_password("srvSalto1")[0], 22),
                    ssh_host_key=None,
                    ssh_pkey=None,
                    ssh_private_key_password=None,
                    ssh_username=self.devuelve_password("UsuarioSrvSalto")[0],
                    ssh_password=self.devuelve_password("UsuarioSrvSalto")[1],
                    mute_exceptions=True,
                    set_keepalive=15,
                    remote_bind_address=(IpRemota, 22, self.devuelve_password("UsuarioRouter")[0], self.devuelve_password("UsuarioRouter")[1]),
                    local_bind_address=('0.0.0.0', self.devuelve_password("lbaPort")[0])
                ) as tunnel:
                    paramiko.util.log_to_file('AssitIT_paramiko.log')
                    client = paramiko.SSHClient()
                    client.load_system_host_keys()
                    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

                    #Control de errores.
                    try:
                        self.textEdit_27.append(str(client.connect('127.0.0.1', 10022, self.devuelve_password("usuarioRouter")[0], self.devuelve_password("usuarioRouter")[1])))
                    except paramiko.SSHException, e:
                        #Se informa que no se puede connectar por SSH
                        self.aviso("rojo", str(e))
                        resolv_connectarSSH = "NO SSH"
                        return resolv_connectarSSH
                    except paramiko.AuthenticationException, f:
                        #Se informa que no se puede connectar por SSH
                        self.aviso("rojo", str(f))
                        resolv_connectarSSH = "NO AUTH"
                        return resolv_connectarSSH
                    stdin, stdout, stderr = client.exec_command(Cmd)

                    str_get = str(stdout.read())
                    client.close()
                    resolv_connectarSSH = str_get
            # TipoConexion: SrvSalto únicamente.
            elif TipoConexion == "SrvSalto":
                s = paramiko.SSHClient()
                s.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                # xxx.xxx.xxx.xxx (IP servidor de Salto).
                s.connect('xxx.xxx.xxx.xxx', 22, self.devuelve_password("UsuarioRouter")[0], self.devuelve_password("UsuarioRouter")[1])
                stdin, stdout, stderr = s.exec_command(Cmd)
                str_get = str(stdout.read())
                s.close()
                resolv_connectarSSH = str(str_get)
            else:
                print "Error TipoConexion no detectado"

        # Conexiones gestionadas por SecureCRT:
        # Index14: SecureCRT
        elif ConfigList[14] == True:
            # TipoConexion: srvSaltoRemoto
            if TipoConexion == "srvSaltoRemoto":
                #Configuración SOCKS5:
                sock = socks.socksocket()
                #Proxy loca:
                sock.set_proxy(socks.SOCKS5, "127.0.0.1", int(1080))
                #IP equipo destino:
                sock.connect((IpRemota, int(22)))
                paramiko.util.log_to_file('SecureCRT_paramiko.log')
                #Añadimos metodo Transport a Paramiko.
                session = paramiko.Transport(sock)
                session.connect(None, username='xxxxxxxxx', password='xxxxxxxxxxx')
                #Código para abrir un canal, 2 opciones a sys CMD o un objeto en PyQt
                cmd_channel = session.open_session()
                time.sleep(3)
                cmd_channel.exec_command(Cmd)
                data = cmd_channel.recv(1024)
                #Como hay un while no se almacena todo en la variable data.
                #Hay que pintar linea por línea. (Pendiente encontrar una solución)
                resolv_connectarSSH =""
                while data:
                    #sys.stdout.write(data)
                    resolv_connectarSSH = data
                    data = cmd_channel.recv(1024)

            # TipoConexion: SrvSalto únicamente.
            elif TipoConexion == "SrvSalto":
                s = paramiko.SSHClient()
                s.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                # xxx.xxx.xxx.xxx (IP servidor de Salto).
                s.connect('xxx.xxx.xxx.xxx', 22, self.devuelve_password("usuarioSrvSalto")[0], self.devuelve_password("usuarioSrvSalto")[1])
                stdin, stdout, stderr = s.exec_command(Cmd)
                str_get = str(stdout.read())
                s.close()
                resolv_connectarSSH = str_get
            else:
                print "Error TipoConexion no detectado"

        else:
            print "NO se ha detectado la forma de gestionar el Túnel SSH"

        QtCore.QTimer.singleShot(10000, lambda: self.listaPorHacer())
        return resolv_connectarSSH