ssh免密登錄實現及Python實現

需求

　　為了保證一台Linux主機的安全，所以我們每個主機登錄的時候一般我們都設置賬號密碼登錄。但是很多時候為了操作方便，我們都通過設置SSH免密碼登錄。
在這里我對本地機器Cloud10和目標機器Cloud11、Cloud12進行免密登錄

大致的三步

1.本地機器生成公私鑰
2.上傳公鑰到目標機器
3.測試免密登錄

具體操作

1.准備工作

• 使用root權限分別修改每台機器的hosts，添加每台機器所對應的IP和主機名（我這里分布式集群是3台機器組成的，所以配置3台，習慣將自己的ip和主機名放在第一行）
  sudo vim /etc/hosts
  刪除文件里內容后添加如下內容
• 
• 查看本地機器的隱藏文件.ssh
• ll  -a
• 
　　　　

　　

2.在本地機器用 ssh-keygen -t rsa 生成一個公私鑰對

• 在ssh目錄下進行，輸入三個回車
• 進入  .ssh目錄  cd  .ssh/
• 發起公鑰 請求   ssh-keygen -t rsa
• 

   

   

　　在  .ssh/ 目錄下，會新生成兩個文件： id_rsa    （私鑰）   id_rsa.pub（公鑰）

　　　　

 

 

 3.上傳公鑰到目標機器

　　ssh-copy-id  -i  ~/root/.ssh/id_rsa.pub   20.200.20.20(目標主機ip地址）

　　ssh-copy-id -i  root@20.200.20.20

　　注意：（@前邊是接受公鑰機器的用戶名，后邊是接受放的ip，因為配置了映射所以ip可以用主機名代替）】

 

　　

 

 

 　　

　　

 

 

 　　查看遠程從節點主機上是否接收到 authorized_keys文件

　　

 

 

 　　

　　

 

 

 　　這個時候 Cloud10的公鑰文件內容會追加寫入Cloud11的  .ssh/authorized_keys文件中

　　文件中查看Cloud11下的authorized_keys文件與Cloud10下的id_rsa.pub中內容是一樣的,如下圖所示

　　

 

 

 

　　

 

 

 　　重啟SSH服務命令使其生效（3台機器都要重啟）

　　sudo  service  shhd restart

　　

　　

 

 　　

　　另外我們要注意：

　　　　.ssh  目錄的權限為700，其下文件authorized_keys和私鑰的權限為600，否則會因為權限問題導致無法免密登錄。我們可以看到登錄后會生成 known_hosts文件生成

chomd  -R 700 .ssh/

sudo chomd 600 .ssh/authorized_keys

4.測試免密登錄

　　使用IP 免密登錄（用戶名相同時，ssh+主機名；如果不同，登錄方式就是  ssh + 用戶名@ip地址）

　　ssh Cloud10

　　ssh Cloud11

　　ssh Cloud12

　　

 

 退出免密登錄

　　exit

　　

 

注意事項

• 免密碼登錄的處理是用戶對用戶的，切換其他用戶后，仍然需要輸入密碼
• 遠程機器的.ssh目錄需要700權限，authorized_keys文件需要600權限
  否則配置是不成功的（每次登錄都得重新去輸入密碼的）

 

 上面只是對 ssh的基本操作，在Linux上實現，那么我們要批量實現ssh免密登錄呢？下面介紹下使用 Python腳本實現免密登錄的過程。

import argparse
import collections
import subprocess


import os
from datetime import datetime
from fabric import Connection
from invoke import Responder

# 存放目標服務器的密碼
HOST_PASSWDS = ['xxxx1','xxxx2','xxxx3']
# 存放錯誤信息的csv文件
FILE_NAME = 'ssh_test_{}_error.scv'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

# 全局變量,我這使用的是 命名元祖
HOST_RESULT = collections.namedtuple('Host',['ip','passwd'])

def logging_error(msg):
    '''
    記錄錯誤信息的函數
    :param msg: 錯誤信息
    :return:
    '''
    base_dir = os.getcwd()
    full_filename = os.path.join(base_dir,FILE_NAME)
    command = "echo '{}'  >> {} ".format(msg,full_filename)
    subprocess.check_call(command,shell=True)

def ssh_connect(ip,user='root',passwd=None,try_passwd=False):
    '''
    使用 ssh 連接服務器
    :param ip: 目標服務器的ip地址
    :param user: 一般ssh免密登錄使用的是 root 用戶
    :param passwd: 目標服務器的密碼，我們統一放入列表中
    :param try_passwd: True  or  False
    :return:
    '''
    if passwd:
        try:
            host = Connection(ip,user=user,connect_kwargs={'password':passwd,'timeout':30})
            host.run('ls',hide=True,warn=True)
            if host.is_connected:
                return host
        except Exception as e:
            return e

    # 測試密碼
    if try_passwd:
        for passwd in HOST_PASSWDS:
            try:
                host = Connection(ip,user=user,connect_kwargs={'password':passwd})
                host.run('ls',hide=True,warn=True)
                if host.is_connected:
                    return host
            except Exception as e:
                return False




def check_host_passwd(iplist):
    '''
    檢測密碼是否可用
    :param iplist: ip列表
    :return: 存放ip和passwd的列表
    '''
    host_list = []
    for ip in iplist:
        host = ssh_connect(ip,try_passwd=True)
        if not host:
            msg = "{} - 登錄失敗！".format(ip)
            logging_error(msg)
            continue
        host_info = HOST_RESULT(ip=ip,passwd=host.connect_kwargs.get('password'))
        host_list.append(host_info)
    return host_list



def gen_master_ssh_key(master_node):
    '''生成秘鑰
    :param master_node: 主服務器的ip和密碼組成的元祖類型
    :return:
    '''
    host = ssh_connect(master_node.ip,passwd=master_node.passwd)
    if not host:
        return False,"{}.master主機登錄失敗".format(master_node.ip)

    # 啟動ssh服務
    host.run('service sshd start',hide=True,warn=True)
    command = 'find /root.ssh/ -name "id_rsa.pub"'
    # 執行 Linux命令，判斷是否存在 id_rsa.pub文件
    result = host.run(command,hide=True,warn=True)
    if len(result.stdout.strip()) == 0:
        id_rsa = Responder(
            pattern = r'/root/.ssh/id_rsa',
            response = '\r\n'
        )
        passphrase = Responder(
            pattern = r'passphrase',
            response = '\r\n'
        )
        yes = Responder(
            pattern = r'(y/n)',
            response = 'y\n'
        )
        # 執行Linux 的 生成秘鑰的命令
        result = host.run('ssh-keygen -t rsa',hide=True,warn=True,watchers=[id_rsa,passphrase,yes],timeout=10)
        if not result.ok:
            return False,"{}-生成ssh證書失敗".format(master_node.ip)
        # print "[info]ip:{}-生成證書文件成功".format(master_node.ip)
        # else:
        #     print "[info] {} - master證書存在，不需要生成".format(master_node.ip)


    host.close()
    return True,'生成證書完成'


def ssh_test_to_other(master,node_list):
    '''
    把生成的證書分發給下面的免密的服務器
    :param master: 主服務器 元祖
    :param node_list: 節點列表
    :return:
    '''
    host = ssh_connect(master.ip,passwd=master.passwd)
    if not host:
        return False,'{} - master 登錄失敗'.format(master.ip)
    for node in node_list:
        passwd = Responder(
            pattern=r'[Pp]assword:',
            response = node.passwd + '\n'
        )
        yes = Responder(
            pattern = r'(yes/no)',
            response = 'yes\n'
        )
        # 清除 known_hosts文件
        clean_command = "ssh-keygen -f '/root/.ssh/known_hosts' -R {}".format(node.ip)
        result = host.run(clean_command,hide=True,warn=True,timeout=30)
        if result.ok:
            return 'known_hosts 記錄清理'
        else:
            return 'konwn_hosts 無需清理'

        # 分發證書的 Linux命令
        scp_crt_command = 'ssh-copy-id -i /root/.ssh/id_rsa.pub {}'.format(node.ip)
        try:
            result = host.run(scp_crt_command,watchers=[passwd,yes],hide=True,warn=True,timeout=20)
            if result.ok:
                return '{} - 證書分發- {} - 成功'.format(master.ip,node.ip)
            else:
                msg = '{} - 證書分發- {} - 不成功'.format(master.ip,node.ip)
                logging_error(msg)
        except Exception as e:
            msg = '{} - 證書分發- {} - 成功 {}'.format(master.ip,node.ip,e.message)
            logging_error(msg)

    return True,''


# 參數解析
def parser_cla():
    '''
    對傳入 Python腳本的參數做解析
    :return:
    '''
    parse = argparse.ArgumentParser()
    #  傳入的服務器的ip/passwd 的格式，主服務器的ip和密碼
    parse.add_argument('-m','--master',help='this ip of master usage:ip/passwd')

    # 節點服務器的ip，用逗號分隔開，可以是單個ip，也可以是多個ip
    parse.add_argument('-s','--nodes',help='this ip of node multiple host split by “，”')

    # 節點文件。可以把多個ip放入文件內，腳本自動讀取文件
    parse.add_argument('-f','--nodefile',help='the full path of node file like /tmp/node.txt')

    # 測試 節點是否可以免密登錄的參數
    parse.add_argument('-c','--check',action='store_true',help='check the nodes is can be ssh login')

    # 密碼的參數，是節點服務器的密碼，可以不輸入，默認使用 HOST_PASSWD中的密碼
    parse.add_argument('-p','--passwd',help='add other passwd for nodes')

    args = parse.parse_args()
    return args


def check_ssh_login(master,nodes):
    '''
    測試免密登錄是否實現的函數
    :param master: 主服務器
    :param nodes: 節點服務器
    :return:
    '''
    # 主服務器的連接
    host = ssh_connect(master.ip,passwd=master.passwd)
    if not host:
        return False,'{} - master 登錄失敗'.format(master.ip)

    # 遍歷節點服務器列表，對每一個ip進行測試
    for node in nodes:
        ssh_command = 'ssh {} echo "ok" '.format(node)
        try:
            result = host.run(ssh_command,pty=True,hide=True,warn=True,timeout=5)
            if result.ok:
                return True,'{} 登錄{}成功'.format(master.ip,node)
            else:
                msg = '{} 登錄{}失敗--{}'.format(master.ip,node,result.stdout)
                logging_error(msg)

        except Exception as e:
            msg = '{} - master登錄{} 失敗--{}'.format(master.ip,node,e)
            logging_error(msg)

    return True,''

def main():
    '''
    運行函數
    :return:
    '''
    # 存放節點服務器的列表
    nodelist = []
    # 對參數的解析
    args = parser_cla()
    # 有主服務器，需指定主服務器的格式
    if args.master:
        try:
            master_ip,master_passwd = args.master.split('/')
        except Exception as e:
            # print '輸入指定格式 --master   master_ip/passwd'
            return False
        # print 'master:{},passwd{}'.format(master_ip,master_passwd)
        master_node = HOST_RESULT(ip=master_ip,passwd=master_passwd)
    else:
        # print '需指定master主機  --master_ip/passwd'
        return False

    #對傳入節點服務器ip進行分割
    if args.nodes:
        nodelist = args.nodes.split(',')
        # print 'nodes:{}'.format(nodelist)

    # 對節點服務器文件的處理
    if args.nodefile:
        file_name = args.nodefile
        base_dir = os.getcwd()
        full_path = os.path.join(base_dir,file_name)
        with open(full_path,'r')as f:
            nodelist = [ip.strip() for ip in f.readline()]
        # print 'nodes:{}'.format(nodelist)
    # 沒有節點  和 節點文件傳入，做出的處理
    if not args.nodes and not args.nodefile:
        # print '需指定分發證書節點  --nodes  or --nodefile'
        return False

    # 對參數密碼的處理，可以輸入多個密碼，逗號分割
    if args.passwd:
        passwds = args.passwd.split(',')
        for i in passwds:
            HOST_PASSWDS.insert(0,i)

    #進行測試
    if args.check:
        # 檢查證書是否可用
        check_ssh_login(master_node,nodelist)
        return

    # 登錄主機生成秘鑰，獲取密碼
    node_result = check_host_passwd(nodelist)
    if len(node_result) == 0:
        # print '無可用節點'
        return False
    status,msg = gen_master_ssh_key(master_node)
    if not status:
        logging_error(msg)
    
    # 分發所有master主機證書到node 
    ssh_test_to_other(master_node,node_result)


if __name__ == '__main__':
    main()