python远程连接paramiko 模块和堡垒机实现

paramiko使用

paramiko模块是基于python实现了SSH2远程安全连接，支持认证和密钥方式，可以实现远程连接、命令执行、文件传输、中间SSH代理功能

安装

pip install paramiko
或 easy_install paramiko
paramiko依赖第三方的Crypto，Ecdsa和pyhton-devel,所以需要安装

paramiko核心组件

SSHClient类

SSHClient类是SSH服务会话的高级表示，该类实现了传输、通道、以及SFTP的校验、建立的方法

• connect 方法

  connect方法实现了远程ssh连接并作校验

  • 参数
    • hostname 连接的目标主机
    • port=SSH_PORT 指定端口
    • username=None 验证的用户名
    • password=None 验证的用户密码
    • pkey=None 私钥方式用于身份验证
    • key_filename=None 一个文件名或文件列表，指定私钥文件
    • timeout=None 可选的tcp连接超时时间
    • allow_agent=True, 是否允许连接到ssh代理，默认为True 允许
    • look_for_keys=True 是否在~/.ssh中搜索私钥文件，默认为True 允许
    • compress=False, 是否打开压缩
    • sock=None,
    • gss_auth=False,
    • gss_kex=False,
    • gss_deleg_creds=True,
    • gss_host=None,
    • banner_timeout=None

• exec_command方法

  远程执行命令的方法，该命令的输入与输出流为标准输入、标出输出、标准错误输出

  • 参数
    • command 执行的命令
    • bufsize=-1 文件缓冲区大小
    • timeout=None
    • get_pty=False

• load_system_host_key方法

  夹在本地公钥文件，默认为~/.ssh/known_hosts

  • 参数
    • filename=None 指定本地公钥文件

• set_missing_host_key_policy方法
  设置连接的远程主机没有本地主机密钥或HostKeys对象时的策略，目前支持三种：

  • AutoAddPolicy 自动添加主机名及主机密钥到本地HostKeys对象，不依赖load_system_host_key的配置。即新建立ssh连接时不需要再输入yes或no进行确认
  • WarningPolicy 用于记录一个未知的主机密钥的python警告。并接受，功能上和AutoAddPolicy类似，但是会提示是新连接
  • RejectPolicy 自动拒绝未知的主机名和密钥，依赖load_system_host_key的配置。此为默认选项

  用法：
  set_missing_host_key_policy(paramiko.AutoAddPolicy())

SFTPClient类

SFTPCLient作为一个sftp的客户端对象，根据ssh传输协议的sftp会话，实现远程文件操作，如上传、下载、权限、状态

• from_transport(cls,t) 创建一个已连通的SFTP客户端通道
• put(localpath, remotepath, callback=None, confirm=True) 将本地文件上传到服务器
  参数confirm：是否调用stat()方法检查文件状态，返回ls -l的结果
• get(remotepath, localpath, callback=None) 从服务器下载文件到本地
• mkdir() 在服务器上创建目录
• remove() 在服务器上删除目录
• rename() 在服务器上重命名目录
• stat() 查看服务器文件状态
• listdir() 列出服务器目录下的文件

远程连接并执行命令

实现远程连接主机，并执行命令，同时记录日志
* 直接验证方式

import paramiko

host = '172.16.200.45'
port = 22
user = 'root'
passwd = ''
# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname=host, port=port, username=user, password=passwd)
paramiko.util.log_to_file('syslogin.log')  #将登录信息记录日志
 # 执行命令
stdin, stdout, stderr = ssh.exec_command('df')
# 获取命令结果
result = stdout.read()
print(result)
# 关闭连接
ssh.close()

• SSHClient 封装 Transport

import paramiko

host = '172.16.200.45'
port = 22
user = 'root'
passwd = ''

transport = paramiko.Transport((host, port))
transport.connect(username=user, password=passwd)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')
print(stdout.read())

• 基于公钥密钥连接

import paramiko
private_key = paramiko.RSAKey.from_private_key_file('/home/fuzengjie/.ssh/id_rsa')

# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname='172.16.200.45', port=22, username='fuzengjie', key=private_key)

# 执行命令
stdin, stdout, stderr = ssh.exec_command('df')
# 获取命令结果
result = stdout.read()

# 关闭连接
ssh.close()

• SSHClient 封装 Transport 使用公钥方式

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/fuzengjie/.ssh/id_rsa')

transport = paramiko.Transport(('172.16.200.45', 22))
transport.connect(username='fuzengjie', pkey=private_key)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')

transport.close()

远程连接实现文件上传下载

• 基于用户名密码上传下载

import paramiko

host = '172.16.200.45'
port = 22
user = 'root'
passwd = ''
transport = paramiko.Transport((host,port))
transport.connect(username=user,password=passwd)

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
a = sftp.put('/Users/fuzengjie/1', '/tmp/fuzj123',confirm=True)
print(a)  #打印上传到服务器上的文件状态
# 将remove_path 下载到本地 local_path
sftp.get('/root/tesst.py', '/Users/fuzengjie/test.py')

transport.close()

• 基于公钥密钥上传下载

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/fuzengjie/.ssh/id_rsa')

transport = paramiko.Transport(('172.16.200.45', 22))
transport.connect(username='fuzengjie', pkey=private_key )

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put('/tmp/location.py', '/tmp/test.py')
# 将remove_path 下载到本地 local_path
sftp.get('/root/123.txt', '/tmp/123')

transport.close()

堡垒机实现

• 架构

堡垒机的主要作用权限控制和用户行为审计，堡垒机就像一个城堡的大门，城堡里的所有建筑就是你不同的业务系统 ， 每个想进入城堡的人都必须经过城堡大门并经过大门守卫的授权，每个进入城堡的人必须且只能严格按守卫的分配进入指定的建筑，且每个建筑物还有自己的权限访问控制，不同级别的人可以到建筑物里不同楼层的访问级别也是不一样的。还有就是，每个进入城堡的人的所有行为和足迹都会被严格的监控和纪录下来，一旦发生犯罪事件，城堡管理人员就可以通过这些监控纪录来追踪责任人。 


• 堡垒机执行流程：

管理员为用户在服务器上创建账号（将公钥放置服务器，或者使用用户名密码）
用户登陆堡垒机，输入堡垒机用户名密码，现实当前用户管理的服务器列表
用户选择服务器，并自动登陆
执行操作并同时将用户操作记录

• 代码

import paramiko
import sys
import os
import socket
import getpass

from paramiko.py3compat import u

# windows does not have termios...
try:
    import termios
    import tty
    has_termios = True
except ImportError:
    has_termios = False

def interactive_shell(chan):
    if has_termios:
        posix_shell(chan)
    else:
        windows_shell(chan)

def posix_shell(chan):
    import select

    oldtty = termios.tcgetattr(sys.stdin)
    try:
        tty.setraw(sys.stdin.fileno())
        tty.setcbreak(sys.stdin.fileno())
        chan.settimeout(0.0)
        log = open('handle.log', 'a+', encoding='utf-8')
        flag = False
        temp_list = []
        while True:
            r, w, e = select.select([chan, sys.stdin], [], [])
            if chan in r:
                try:
                    x = u(chan.recv(1024))
                    if len(x) == 0:
                        sys.stdout.write('\r\n*** EOF\r\n')
                        break
                    if flag:
                        if x.startswith('\r\n'):
                            pass
                        else:
                            temp_list.append(x)
                        flag = False
                    sys.stdout.write(x)
                    sys.stdout.flush()
                except socket.timeout:
                    pass
            if sys.stdin in r:
                x = sys.stdin.read(1)
                import json

                if len(x) == 0:
                    break

                if x == '\t':
                    flag = True
                else:
                    temp_list.append(x)
                if x == '\r':
                    log.write(''.join(temp_list))
                    log.flush()
                    temp_list.clear()
                chan.send(x)

    finally:
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)

def windows_shell(chan):
    import threading

    sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n")

    def writeall(sock):
        while True:
            data = sock.recv(256)
            if not data:
                sys.stdout.write('\r\n*** EOF ***\r\n\r\n')
                sys.stdout.flush()
                break
            sys.stdout.write(data)
            sys.stdout.flush()

    writer = threading.Thread(target=writeall, args=(chan,))
    writer.start()

    try:
        while True:
            d = sys.stdin.read(1)
            if not d:
                break
            chan.send(d)
    except EOFError:
        # user hit ^Z or F6
        pass

def run():
    default_username = getpass.getuser()
    username = input('Username [%s]: ' % default_username)
    if len(username) == 0:
        username = default_username

    hostname = input('Hostname: ')
    if len(hostname) == 0:
        print('*** Hostname required.')
        sys.exit(1)

    tran = paramiko.Transport((hostname, 22,))
    tran.start_client()

    default_auth = "p"
    auth = input('Auth by (p)assword or (r)sa key[%s] ' % default_auth)
    if len(auth) == 0:
        auth = default_auth

    if auth == 'r':
        default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
        path = input('RSA key [%s]: ' % default_path)
        if len(path) == 0:
            path = default_path
        try:
            key = paramiko.RSAKey.from_private_key_file(path)
        except paramiko.PasswordRequiredException:
            password = getpass.getpass('RSA key password: ')
            key = paramiko.RSAKey.from_private_key_file(path, password)
        tran.auth_publickey(username, key)
    else:
        pw = getpass.getpass('Password for %s@%s: ' % (username, hostname))
        tran.auth_password(username, pw)

    # 打开一个通道
    chan = tran.open_session()
    # 获取一个终端
    chan.get_pty()
    # 激活器
    chan.invoke_shell()

    interactive_shell(chan)

    chan.close()
    tran.close()

if __name__ == '__main__':
    run()