精华内容
下载资源
问答
  • paramiko使用
    千次阅读
    2019-09-16 16:16:11

    paramiko使用密码登录

    import paramiko
    
    transport = paramiko.Transport('xx.xx.xx.xx', 22)
    transport.connect(username='root', password='xxx')
    client = paramiko.SSHClient()
    client._transport = transport
    stdin,stdout,stderr = client.exec_command('cd platform;python test.py')
    print(stdout.read().decode('utf8'))
    transport.close()
    
    

    paramiko使用秘钥登录

    import paramiko
    
    private_key = paramiko.RSAKey.from_private_key_file('./id_rsa')
    transport = paramiko.Transport(('xx.xx.xx.xx', 22))
    transport.connect(username='root', pkey=private_key)
    client = paramiko.SSHClient()
    client._transport = transport
    stdin, stdout, stderr = client.exec_command('cd platform;python test.py')
    print(stdout.read().decode('utf-8')) 
    transport.close()
    
    

    paramiko上传文件

    import paramiko
    
    tran = paramiko.Transport(('xx.xx.xx.xx', 22))  
    tran.connect(username="root", password='xxx') 
    sftp = paramiko.SFTPClient.from_transport(tran)
    localpath = "./your_name.log"
    remotepath = "/root/platform/your_name.log"
    sftp.put(localpath, remotepath)
    tran.close()
    
    

    paramiko下载文件

    import paramiko
    
    tran = paramiko.Transport(('xx.xx.xx.xx', 22))
    tran.connect(username="root", password='xxx')
    sftp = paramiko.SFTPClient.from_transport(tran)
    localpath = "./your_name_szj.log"
    remotepath = "/root/platform/your_name.log"
    sftp.get(remotepath, localpath)
    tran.close()
    
    
    
    更多相关内容
  • python Paramiko使用示例

    2020-09-24 10:25:37
    主要介绍了python Paramiko使用示例,帮助大家远程控制类 UNIX 系统,感兴趣的朋友可以了解下。
  • 基本思路为利用paramiko ssh到服务器上,起一个线程用tail -f命令实时获取日志输出,起另外一个线程用‘cat /sys/class/thermal/thermal_zone0/temp’命令定时获取cpu,gpu温度。 代码 def get_report_info_perid...
  • import paramiko paramiko.util.log_to_file('paramiko.log') # 记录日志文件 ssh = paramiko.SSHClient() try: ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('139.xx.xx.xx',...
  • 前言 这几年一直在it行业里摸爬滚打,一路走来,不少总结了一些python行业里的高频面试,看到大部分初入行的新鲜血液,还在为各样的面试题答案或收录有各种困难问题 于是乎,我自己开发了一款面试宝典...Paramiko Param

    前言

    这几年一直在it行业里摸爬滚打,一路走来,不少总结了一些python行业里的高频面试,看到大部分初入行的新鲜血液,还在为各样的面试题答案或收录有各种困难问题

    于是乎,我自己开发了一款面试宝典,希望能帮到大家,也希望有更多的Python新人真正加入从事到这个行业里,让python火不只是停留在广告上。

    微信小程序搜索:Python面试宝典

    或可关注原创个人博客:https://lienze.tech

    也可关注微信公众号,不定时发送各类有趣猎奇的技术文章:Python编程学习

    Paramiko

    ParamikoSSHv2协议的Python实现,提供客户端和服务器功能

    Paramiko本身是一个围绕SSH网络概念的纯Python接口

    利用paramiko我们可以通过Python方便的进行ssh操作


    paramiko包含两个核心组件:SSHClientSFTPClient

    SSHClient

    SSHClient的作用类似于Linuxssh命令,是对SSH会话的封装

    该类封装了传输Transport,通道ChannelSFTPClient建立的方法open_sftp,通常用于执行远程命令

    API

    • class paramiko.client.SSHClient

    创建SSH客户端实例

    • SSHClient.connect(hostname, port=22, username=None, password=None, pkey=None, key_filename=None, timeout=None, allow_agent=True, look_for_keys=True, compress=False..)
    # 参数解释
    - 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:是否打开压缩
    

    通过验证连接远程服务端


    • SSHClient.exec_command(command, bufsize=-1, timeout=None, get_pty=False, environment=None)
    # 参数解释
    - command:要执行的命令
    - bufsize:与Python中文件对象的同名函数解释相同,缓冲区大小
    - timeout:设置命令的超时相应事件
    - get_pty:从服务器请求一个伪终端(默认为假)
    - environment:一个当前shell环境的字典,远程命令的默认执行环境
    

    command参数为要执行的shell命令,打开一个新通道并执行请求的命令

    该函数的返回结果为一个元组,其中包含stdinstdoutstderr,也就是我们常见的标准输入,输出以及出错

    一般来说,命令的结果我们将通过stdout进行获取


    • SSHClient.close()

    关闭SSH连接


    • SSHClient.invoke_shell(term=’vt100’, width=80, height=24, width_pixels=0, height_pixels=0, environment=None)
    # 参数解释
    - term:模拟终端类型
    - width:终端长度
    - height:终端宽度
    - width_pixels:终端的像素宽度
    - height_pixels:终端的像素高度
    - environment:命令的shell环境
    

    ssh服务器上启动交互式shell会话

    一个新的通道被打开并连接到,使用请求的终端类型和大小的伪终端,并作为返回值

    换句通俗的话来讲,就是创建了一个实际的shell窗口空间进行命令交互


    • SSHClient.set_missing_host_key_policy(policy)

    设置连接到没有已知主机密钥的服务器时要使用的策略

    常见使用策略为paramiko.client.AutoAddPolicy,其意义为自动将主机名和新主机密钥添加到本地主机密钥对象并保存

    实例代码

    以下是一个简单的通过SSHClient建立的通道进行命令的传输与返回结果的获取的代码!

    import paramiko 
    
    def connect(hostname,username,password):
    	client = paramiko.SSHClient() 
        # 初始化
    	client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        # 设置密钥策略
    	client.connect(hostname,username=username,password=password)
        # 连接主机
    	return client
    
    def exec_cmd(client,cmd):
    	stdin,stdout,stderr = client.exec_command(cmd)
    	return stdout.read().decode(),stderr.read().decode()
    def main():
    	hostname = '192.168.0.104'
    	username = 'pi'
    	password = '123456'
    	cmd = 'ps -aux'
    
    	client = connect(hostname,username,password)
    	res = exec_cmd(client, cmd)
    	if res[0]:
    		print(res[0])
    	if res[1]:
    		print('[E]:\n',res[1])
    	client.close()
    if __name__ == '__main__':
    	main()
    

    上面的代码通过默认建立好的连接对象进行命令的传输以及返回结果的获取

    invoke_shell

    • 接下来使用invoke_shell进行虚拟终端的连接,首先初始化SSH通道
    class SSHChannle:
        def __init__(self, host, username, password, port=22):
            '''
                初始化SSH通道
            '''
            self.sh = paramiko.SSHClient()
            self.sh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            self.sh.connect(host, username=username, password=password)
            self.channle = self.sh.invoke_shell()
    
    • 思路为开启两个线程,分别负责命令的接收与命令的发送
    def get_ssh_recv(self):
        '''
            接收SSH通道中发来的消息
        '''
        while not self.channle.exit_status_ready():
            # 如果远程进程已退出并返回退出状态,则返回true
            time.sleep(0.1)
            try:
                buf = self.channle.recv(1024).decode('utf-8')
                print(buf,end='')
                sys.stdout.flush()
            except Exception as ex:
                print(ex)
    
    def send_ssh_cmd(self):
        '''
            发送命令给SSH通道
        '''
        while not self.channle.exit_status_ready():
            cmd = input()
            try:
                self.channle.send(cmd + '\r')
            except Exception as ex:
                print(ex)
            sys.stdin.flush()
    
    • 在实例中定义run函数用来开启两个线程并负责线程的资源回收以及SSH通道的关闭
    def run(self):
        ssh_recv_thread = threading.Thread(target=self.get_ssh_recv)
        ssh_send_thread = threading.Thread(target=self.send_ssh_cmd)
        ssh_recv_thread.start()
        ssh_send_thread.start()
    
        ssh_recv_thread.join()
        ssh_send_thread.join()
    
        self.sh.close()  # 关闭通道
    
    • win下的CMD中查看效果,其中的乱码格式其实为连接后命令传输的特殊标记格式,可以在后面结合前端中类似xterm.js等插件查看到实际花里胡哨的效果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A5wuYlKp-1634896751504)(/Users/lienze/Documents/Python Courseware/MD格式/静态资源/invoke_shell.gif)]

    SFTPClient

    SFTPClient的作用类似与Linuxsftp命令,是对SFTP客户端的封装

    用以实现远程文件操作,如文件上传、下载、修改文件权限等操作

    API

    • 官方文档:docs.paramiko.org/en/2.4/api/sftp.html

    • sftp=paramiko.SFTPClient.from_transport(t,window_size=None,max_packet_size=None)

    # 参数解释
    - t:该参数可以通过paramiko.Transport( (ip,port )),创建一个已通过验证的传输通道,参数为IP和端口的二元组
    

    根据参数t指定的已验证传输通道进行SFTP客户端的创建

    • sftp.put(localpath, remotepath, callback=None, confirm=True)

    上传本地路径为localpath的文件到目标主机remotepath

    • sftp.get(remotepath, localpath, callback=None)

    下载远程路径为remotepath路径的的文件到本地主机localpath

    • open(filename, mode=’r’, bufsize=-1)

    打开位于远程主机上的文件,与open函数类似,返回文件对象

    • listdir(path='.')

    返回给定路径下文件及目录的列表,默认路径为当前工作目录

    • chdir(path=None)

    修改当前SFTP连接会话的工作目录

    • lstat(path)

    检索当前path所指向的文件信息

    • mkdir(path,mode=511)

    根据path在目标主机创建默认权限为511的目录

    • rmdir(path)

    删除给定path所指向的目录

    • remove(path)

    删除给定path所指向的文件

    实例代码

    以下是一个比较简陋的关于SFTPClient的测试代码

    import paramiko
    def connecnt(hostname,username,password): #创建连接对象
        client = paramiko.Transport( (hostname,22))
        try:
            client.connect(username=username,password=password)
        except paramiko.SSHException:
            return None
        sftp_client = paramiko.SFTPClient.from_transport(client)
        return sftp_client
    
    def main():
        hostname = '192.168.0.104'
        username = 'pi'
        password = '123456'
        sftp_client = connecnt(hostname,username,password)
        remotefile_path = '/home/pi/test' # 目标主机文件路径
        localfile_path = '/home/test' # 本地主机文件路径
    
        sftp_client.put(localfile_path, remotefile_path) #上传本地test文件到远程
        sftp_client.get(remotefile_path, localfile_path) #下载远程test文件到本地
        print(sftp_client.listdir())
        print(sftp_client.lstat(remotefile_path))
        with sftp_client.open(remotefile_path) as fp:
            print(fp.read().decode())
        #print(sftp_client.remove(remotefile_path))
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • paramiko使用秘钥连接

    千次阅读 2019-08-02 11:26:13
    代码如下 def ssh_scp(ip, port, ... private_key = paramiko.RSAKey.from_private_key_file('/usr/id_rsa') # 创建一个SSH客户端对象 ssh = paramiko.SSHClient() # 设置访问策略 ssh.set_missing_host_key_p...

    代码如下

    def ssh_scp(ip, port, user):
        private_key = paramiko.RSAKey.from_private_key_file('/usr/id_rsa')
        # 创建一个SSH客户端对象
        ssh = paramiko.SSHClient()
        # 设置访问策略
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        # 创建连接
        ssh.connect(ip, port, user, pkey=private_key)
        sftp = ssh.open_sftp()
        return sftp

    代码:paramiko.RSAKey.from_private_key_file('/usr/id_rsa') 是选择你的秘钥,该方法的第二个参数为秘钥的密码,同时你要将你的公钥添加给你的ssh用户

    注意:如果你生成秘钥有设置密码的话需要指定你的密码,源码如下图

    这里主要记录下关于在windows下创建秘钥,我是在git上面生成,生成的命令和linux下有一点点不一样,需要指定 -m 参数,不然生成的秘钥不能使用,会出现:paramiko.ssh_exception.SSHException: not a valid RSA private key file 错误

     

    windows生成秘钥

    该问题解决参考:https://www.cnblogs.com/dbf-/p/11114264.html

    通过 ssh-keygen -m PEM -t rsa 命令生成 RSA 格式的密钥对,如下图所示,生成的秘钥是 RSA 格式的,参数指定密钥的格式,PEM(也就是 RSA 格式)是之前使用的旧格式

    PS:如果像linux中,默认使用 ssh-keygen -t rsa 的方式生成秘钥,秘钥格式如下,但是paramiko使用该格式的秘钥连接windows服务器会出错

     

     

    展开全文
  • Paramiko使用

    2019-09-25 03:38:53
    1、下载安装pycrypto-2.6.1.tar.gz (apt-getinstallpython-dev)  解压,进入,python setup.py build【编译】,python setup.py install 【安装... 2、下载安装paramiko-1.10.1.tar.gz   解压,进入,pyth...

    1、下载安装 pycrypto-2.6.1.tar.gz  (apt-get install python-dev)

        解压,进入,python setup.py build【编译】,python setup.py install 【安装】  ----》import Crypto

      2、下载安装 paramiko-1.10.1.tar.gz  

        解压,进入,python setup.py build【编译】,python setup.py install 【安装】---》  import paramiko

     

     

    1、连接远程服务器,并执行操作
    用户名和密码连接1

    import paramiko
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect('10.10.50.30', 22, 'root', '123456')
    stdin, stdout, stderr = ssh.exec_command('ifconfig')
    print stdout.read()
    ssh.close();
    用户名和密码连接2  (SSHClient 封装 Transport)推荐

     

    transport = paramiko.Transport(('10.10.50.30', 22))
    transport.connect(username='root', password='jichuang')
    ssh = paramiko.SSHClient()
    ssh._transport = transport
    stdin, stdout, stderr = ssh.exec_command('ifconfig')
    print stdout.read()
    transport.close()
    

     

     
     

    公钥私钥链接
    ssh-keygen -t rsa
    ssh-copy-id -i .ssh/id_rsa.pub "-p 22 root@10.10.50.30"

    import paramiko
    private_key_path = '/root/.ssh/id_rsa' #本机私钥存放位置
    key = paramiko.RSAKey.from_private_key_file(private_key_path)
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect('10.10.50.31 ', 22, 'root' ,pkey=key)
    stdin, stdout, stderr = ssh.exec_command('df')
    print stdout.read()
    ssh.close();
    

      

    公钥私钥链接2 (SSHClient 封装 Transport)推荐

    import paramiko
    private_key = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
    transport = paramiko.Transport(('10.10.50.30', 22))
    transport.connect(username='root', pkey=private_key)
    ssh = paramiko.SSHClient()
    ssh._transport = transport
    stdin, stdout, stderr = ssh.exec_command('df')
    transport.close()
    

      

    2、SFTP上传下载
    基于用户名和密码
    import os,sys
    import paramiko
    t = paramiko.Transport(('10.10.50.30',22))
    t.connect(username='yangmv',password='123456')
    sftp = paramiko.SFTPClient.from_transport(t)
    sftp.put('C:\Users\yangmingwei\Desktop\error.jpg','/home/yangmv/error.jpg')
    #将error.jpg上传到服务器/home/yangmv目录
    sftp.get('/home/yangmv/sftp.txt','C:\Users\yangmingwei\Desktop\sftp.txt')
    #将sftp.txt下载到本机桌面
    t.close()
    

      

    基于公钥秘钥上传下载
    import paramiko
     
    private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')
     
    transport = paramiko.Transport(('hostname', 22))
    transport.connect(username='yangmv', 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('remove_path', 'local_path')
     
    transport.close()
    

      

     
     
    Paramiko 批量执行命令
    版本一:
    缺点: 每次执行一个操作,就要进行一次连接
    import paramiko
    import uuid
    class Comm(object):
        def __init__(self):     #初始化参数
    self.host = '10.10.50.30'
    self.port = 22
    self.username = 'root'
    self.pwd = '123456'
    self.file_name = ''
    
    def create_file(self):  #本地创建文件
    file_name = str(uuid.uuid4())   #uuid创建一个不会重复的随机字符串作为文件名
    with open(file_name,'w') as f_obj:
                f_obj.write('sb')
            return file_name    #返回文件名
    def run(self):
            self.upload()       #执行上传
    self.rename()       #执行重命名
            
    def upload(self):       #用于上传
    self.file_name = self.create_file()
            t = paramiko.Transport((self.host,self.port))
            t.connect(username=self.username,password=self.pwd)
            sftp = paramiko.SFTPClient.from_transport(t)
            sftp.put(self.file_name,'/home/yangmv/%s'%self.file_name)
            t.close()
        def rename(self):       #用于重命名
    ssh = paramiko.SSHClient()
            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            ssh.connect(self.host, self.port, self.username, self.pwd)
            stdin, stdout, stderr = ssh.exec_command('mv /home/yangmv/%s /home/yangmv/xxxx.txt'%(self.file_name))
            print stdout.read()
            ssh.close();
    startcmd = Comm()
    startcmd.run()
    

      


    版本二:(推荐)
    优点:不管执行多少个操作,都只连接一次
    import paramiko
    import uuid
    class Comm(object):
        def __init__(self):     #初始化参数
    self.host = '10.10.50.30'
    self.port = 22
    self.username = 'root'
    self.pwd = '123456'
    
    def create_file(self):  #本地创建文件
    file_name = str(uuid.uuid4())   #uuid创建一个不会重复的随机字符串作为文件名
    with open(file_name,'w') as f_obj:
                f_obj.write('sb2')
            return file_name    #返回文件名
    def run(self):
            self.connect()
            self.upload()       #执行上传
    self.rename()       #执行重命名
    self.close()
    
        def connect(self):        #用于ssh连接
    t = paramiko.Transport((self.host,self.port))
            t.connect(username=self.username,password=self.pwd)
            self.__transport = t
        def close(self):          #用于ssh关闭
    self.__transport.close()
        def upload(self):       #用于上传
    self.file_name = self.create_file()
            sftp = paramiko.SFTPClient.from_transport(self.__transport)
            sftp.put(self.file_name,'/home/yangmv/%s'%self.file_name)
        def rename(self):       #用于重命名
    ssh = paramiko.SSHClient()
            ssh._transport = self.__transport
            stdin, stdout, stderr = ssh.exec_command('mv /home/yangmv/%s /home/yangmv/ssss.txt'%self.file_name)
            result = stdout.read()
    startcmd = Comm()
    startcmd.run()
    

      

     
    Paramiko持续连接服务器1 select
    import paramiko
    import select   #无法在windows下操作
    import sys
    t = paramiko.Transport(('10.10.50.31', 22))
    t.start_client()
    #基于公钥验证
    ##default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
    #key = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
    #t.auth_publickey('root',key)
    #基于用户密码验证
    t.auth_password('root', '123456')
    
    #打开一个通道
    chan = t.open_session()
    #获取一个终端
    chan.get_pty()
    #激活器
    chan.invoke_shell()
    
    #########
    # 利用sys.stdin,肆意妄为执行操作
    # 用户在终端输入内容,并将内容发送至远程服务器
    # 远程服务器执行命令,并将结果返回
    # 用户终端显示内容
    while True:
        # 监视用户输入和服务器返回数据
    # sys.stdin 处理用户输入
    # chan 是之前创建的通道,用于接收服务器返回信息
    r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
        if chan in r_list:                  #接收命令执行后返回的结果
    try:
                x = chan.recv(1024)
                if len(x) == 0:
                    print '\r\n*** EOF\r\n',
    break
    sys.stdout.write(x)
                sys.stdout.flush()
            except socket.timeout:
                pass
        if sys.stdin in r_list:             #用户输入
    inp = sys.stdin.readline()
            chan.sendall(inp)               #把用户输入命令发送执行
    #########
    chan.close()
    t.close()
    

      

    成功登陆机器,并可以持续连接,不断输入命令,并到达返回结果
     
    Paramiko持续连接服务器2  改进
    1的缺点:
        输入端,以行为单位,敲回车后才执行命令     ( ls + 回车 → 发送远端)
        无法使用tab补全
    2的改进:
        改变默认终端,由 行stdin, 一个字符stdin     ( l    → 发送 远端 ,s   → 发送 远端   
        每输入一次,向远端发送一次 
         无法使用tab补全
    import paramiko
    import select   #无法在windows下操作
    import sys
    import termios
    import tty
    
    t = paramiko.Transport(('10.10.50.31', 22))
    t.start_client()
    #基于公钥验证
    ##default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
    #key = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
    #t.auth_publickey('root',key)
    #基于用户密码验证
    t.auth_password('root', '123456')
    
    #打开一个通道
    chan = t.open_session()
    #获取一个终端
    chan.get_pty()
    #激活器
    chan.invoke_shell()
    
    #########
    #获取原tty属性
    oldtty = termios.tcgetattr(sys.stdin)
    try:
        # 为tty设置新属性
    # 默认当前tty设备属性:
    # 输入一行回车,执行
    # CTRL+C 进程退出,遇到特殊字符,特殊处理。
    # 这是为原始模式,不认识所有特殊符号
    # 放置特殊字符应用在当前终端,如此设置,将所有的用户输入均发送到远程服务器
    tty.setraw(sys.stdin.fileno())
        chan.settimeout(0.0)
        while True:
            #监视用户输入和远程服务器的返回数据socket
            #阻塞,直到句柄可用
    r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
            if chan in r_list:
                try:
                    x = chan.recv(1024)
                    if len(x) == 0:
                        print '\r\n*** EOF\r\n',
    break
    sys.stdout.write(x)
                    sys.stdout.flush()
                except socket.timeout:
                    pass
            if sys.stdin in r_list:
                inp = sys.stdin.read(1)     #每次读1个字符
    if len(inp) == 0:
                    break
    chan.sendall(inp)
    finally:
        #退出后恢复终端属性
    termios.tcsetattr(sys.stdin,termios.TCSADRAIN,oldtty)
    
    #########
    chan.close()
    t.close()
    

      

     
     
     
    Paramiko持续连接服务器3  记录操作日志
    import paramiko
    import select   #无法在windows下操作
    import sys
    import termios
    import tty
    
    t = paramiko.Transport(('10.10.50.31', 22))
    t.start_client()
    t.auth_password('root', '123456')
    
    chan = t.open_session()
    chan.get_pty()
    chan.invoke_shell()
    
    #########
    oldtty = termios.tcgetattr(sys.stdin)
    try:
        tty.setraw(sys.stdin.fileno())
        chan.settimeout(0.0)
        f  = open('record.log','a')
        records = []
        while True:
            r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
            if chan in r_list:
                try:
                    x = chan.recv(1024)
                    if len(x) == 0:
                        print '\r\n*** EOF\r\n',
    f.close()   #异常中断,或者exit退出时保存
    break
    sys.stdout.write(x)
                    sys.stdout.flush()
                except socket.timeout:
                    pass
            if sys.stdin in r_list:
                inp = sys.stdin.read(1)
                records.append(inp)  #把个字符键入列表暂时保存 ['l','s']
    if len(inp) == 0:
                    break
                if inp == '\t':     #tab键不记录
    pass
                if inp == '\r':     #每次回车
    cmd = ''.join(records).replace('\r','\n') #[ls]+换行
    f.write(cmd)
                    records = []    #每次记录一个条命令
    chan.sendall(inp)
    finally:
        termios.tcsetattr(sys.stdin,termios.TCSADRAIN,oldtty)
    #########
    chan.close()
    t.close()
    

      

    成功记录
     
    Paramiko持续连接服务器4 适用windows
    import paramiko
    import sys
    import threading
    
    t = paramiko.Transport(('10.10.50.31', 22))
    t.start_client()
    t.auth_password('root', '123456')
    
    chan = t.open_session()
    chan.get_pty()
    chan.invoke_shell()
    
    #########
    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
    #########
    chan.close()
    t.close()
    

      

     
     
     
     

     

    转载于:https://www.cnblogs.com/yangmv/p/5169924.html

    展开全文
  • Python黑帽子——通过Paramiko使用SSH

    千次阅读 2017-06-22 11:03:35
    首先下载paramiko pip install paramiko 查看并启动ssh服务 service ssh status service ssh start 另ssh添加用户的方法: 添加用户: useradd -d /home/qing qing passwd qing 赋予ssh权限 vi /etc/ssh/sshd_...
  • 主要介绍了Python Paramiko模块的使用实际案例,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 1、使用 paramiko 模块ssh 登陆到 linux 执行nohup命令不生效 # 执行命令 def command(ssh_config, cmd, result_print=None, nohup=False): ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy...
  • 近期,需要实现一些功能,通过python去控制远程linux,这里就接触到了paramiko模块 这里有挺多小技巧和大家一起分享下 1.通过SSH去连接远程服务器 由于如果linux host/user等不对,都会引起连接时候的异常,所以我么...
  • paramiko模块的使用

    2019-07-23 13:52:36
    paramiko模块的使用(含上传本地文件或文件夹到服务器,以及下载服务器文件到本地) 1. paramiko连接  使用paramiko模块有两种连接方式,一种是通过paramiko.SSHClient()函数,另外一种是通过paramiko....
  • Python~paramiko使用

    千次阅读 2022-04-21 00:32:39
    paramiko包含了两个核心组件:SSHClient 和 SFTPClient SSHClient 类:SSHClient 类是与SSH服务器会话的高级表示。该类集成了Transport,Channel 和SFTPClient 类。 SFTClient 类:该类通过一个打开的SSH Transport...
  • paramiko使用介绍,Python远程操作Linux paramiko是基于Python实现的SSH2远程安全连接,支持认证和秘钥方式。可以实现远程命令执行、文件传输、中间SSH代理等功能。paramiko包含两个核心组件,一个为SSHClient类,...
  • python paramiko 使用

    2019-04-07 15:59:05
    使用paramiko 远程执行命令 import paramiko def remote_execution_command(ip,user,passwd,cmd,Ifsource,loginname=None,get_pty=False,queue_info=None): #创建SSH对象 ssh = paramiko.SSHClient() # ...
  • 使用paramiko可以很好的解决以上问题,比起前面的方法,它仅需要在本地上安装相应的软件(python以及PyCrypto),对远程服务器没有配置要求,对于连接多台服务器,进行复杂的连接操作特别有帮助。下面本文就来详细...
  • paramiko是python一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接1、可以远程操作服务器文件例如:df:查看磁盘使用情况mkdir:创建目录mv/cp/mkdir/rmdir:对文件或目录进行操作/sbin/...
  • 使用我们编写的bhnet工具介绍和发送数据非常方便,但有时候需要通过加密流量来避免,这是更明智的选择。最常用的办法就是使用secure shell(SSH)发送流量。 paramiko是用python语言写的一个模块,遵循SSH2协议,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,934
精华内容 6,373
关键字:

paramiko使用

友情链接: 博弈论.zip