paramiko：将ssh会话嵌套到另一台计算机，同时保留paramiko功能（ProxyJump）

Question

 MyLocalMachine ----||----> MiddleMachine --(netcat)--> AnotherMachine
 ('localhost')  (firewall)   ('1.1.1.1')                 ('2.2.2.2')

• 从MyLocalMachine到AnotherMachine
没有直接连接
• MiddleMachine上的SSH服务器将不接受任何打开连接到AnotherMachine
的直接TCPIP通道的尝试
• 我不能使用SSH密钥。只能通过给定的用户名和密码进行连接。
• 我不能使用sshpass
• 我不能使用pexpect
• 我要自动连接
• 我想保留paramiko的所有功能

我可以使用以下代码部分地实现这一点：

cli = paramiko.SSHClient()
cli.set_missing_host_key_policy(paramiko.AutoAddPolicy())
proxy = paramiko.ProxyCommand('ssh user@1.1.1.1 nc 2.2.2.2 22')
cli.connect(hostname='2.2.2.2', username='user', password='pass', sock=proxy)

问题是，因为proxycommand使用subprocess.popen来运行给定的命令，所以它要求我根据用户输入给出密码“ad-hoc”（而且，它要求mylocalmachine上的操作系统安装ssh-这并不总是这样）。

由于proxycommand的方法(recv和send)是一个简单的绑定到专用的popen方法，所以我想知道是否可以欺骗paramiko客户机使用另一个客户机的会话作为代理？

Answer 1

更新15.05.18：增加了缺失的代码（复制粘贴神对我没有好处）。

TL；DR：我使用简单的exec_command调用和一个假装是sock的类来实现这一点。

总结一下：

null

下面的代码定义了一个类，可以用来代替paramiko.proxyCommand。它提供了标准socket对象所提供的所有方法。该类的init方法接受exec_command()通常返回的3元组：

注意：我对它进行了广泛的测试，但你不应该认为任何事情都是理所当然的。这是一个黑客。

import paramiko
import time
import socket     
from select import select                                                       


class ParaProxy(paramiko.proxy.ProxyCommand):                      
    def __init__(self, stdin, stdout, stderr):                             
        self.stdin = stdin                                                 
        self.stdout = stdout                                               
        self.stderr = stderr
        self.timeout = None
        self.channel = stdin.channel                                               

    def send(self, content):                                               
        try:                                                               
            self.stdin.write(content)                                      
        except IOError as exc:                                             
            raise socket.error("Error: {}".format(exc))                                                    
        return len(content)                                                

    def recv(self, size):                                                  
        try:
            buffer = b''
            start = time.time()

            while len(buffer) < size:
                select_timeout = self._calculate_remaining_time(start)
                ready, _, _ = select([self.stdout.channel], [], [],
                                     select_timeout)
                if ready and self.stdout.channel is ready[0]:
                      buffer += self.stdout.read(size - len(buffer))

        except socket.timeout:
            if not buffer:
                raise

        except IOError as e:
            return ""

        return buffer

    def _calculate_remaining_time(self, start):
        if self.timeout is not None:
            elapsed = time.time() - start
            if elapsed >= self.timeout:
                raise socket.timeout()
            return self.timeout - elapsed
        return None                                   

    def close(self):                                                       
        self.stdin.close()                                                 
        self.stdout.close()                                                
        self.stderr.close()
        self.channel.close()                                                                                                                            

下面展示了我是如何使用上面的类来解决我的问题的：

# Connecting to MiddleMachine and executing netcat
mid_cli = paramiko.SSHClient()
mid_cli.set_missing_host_key_policy(paramiko.AutoAddPolicy())
mid_cli.connect(hostname='1.1.1.1', username='user', password='pass')
io_tupple = mid_cli.exec_command('nc 2.2.2.2 22')

# Instantiate the 'masquerader' class
proxy = ParaProxy(*io_tupple)

# Connecting to AnotherMachine and executing... anything...
end_cli = paramiko.SSHClient()
end_cli.set_missing_host_key_policy(paramiko.AutoAddPolicy())
end_cli.connect(hostname='2.2.2.2', username='user', password='pass', sock=proxy)
end_cli.exec_command('echo THANK GOD FINALLY')