【计算机网络】5、ssh、sshpass、sftp 原理+脚本+程序超详细介绍

呆呆的猫

已于 2023-09-01 09:46:21 修改

阅读量1.9k

点赞数

分类专栏：计算机网络文章标签： ssh 安全网络

于 2022-10-27 00:28:58 首次发布

本文链接：https://blog.csdn.net/jiaoyangwm/article/details/127543770

版权

计算机网络专栏收录该内容

17 篇文章 5 订阅

订阅专栏

文章目录

一、SSH 工作原理
- 1.1 基于口令（密码）的认证
- 1.2 基于公钥（pubKey）的认证
二、SSH 实践
- 2.1 生成密钥操作
- 2.2 登录操作
三、known_hosts
四、sshpass
五、建立 SSH 免密脚本
- 5.1 create_sshkey.sh
- 5.2 sshcopy.sh
六、go:sftp远程传输文件+ssh执行命令

SSH是一种协议标准，其目的是实现安全远程登录以及其它安全网络服务。

SSH仅仅是一协议标准，其具体的实现有很多，既有开源实现的OpenSSH，也有商业实现方案。使用范围最广泛的当然是开源实现OpenSSH。

一、SSH 工作原理

在讨论SSH的原理和使用前，我们需要分析一个问题：为什么需要SSH？SSH和telnet、ftp等协议主要的区别在于安全性。如何实现数据的安全呢？首先想到的实现方案肯定是对数据进行加密。加密的方式主要有两种：

对称加密（即秘钥加密）
非对称加密（即公钥加密）

所谓对称加密，指加密解密使用同一套秘钥。如下图所示：

虽然对称加密的加密强度高、很难破解。但实际应用过程中不得不面临一个棘手的问题：如何安全的保存密钥呢？尤其是考虑到数量庞大的Client端，很难保证密钥不被泄露。一旦一个Client端的密钥被窃据，那么整个系统的安全性也就不复存在。

为了解决这个问题，非对称加密应运而生。非对称加密有两个密钥：“公钥”和“私钥”。两个密钥的特性：公钥加密后的密文，只能通过对应的私钥进行解密。而通过公钥推理出私钥的可能性微乎其微。

非对称加密的登录流程如下图：
1.远程Server收到Client端用户TopGun的登录请求，Server把自己的公钥发给用户。
2.Client使用这个公钥，将密码进行加密。
3.Client将加密的密码发送给Server端。
4.远程Server用自己的私钥，解密登录密码，然后验证其合法性。
5.若验证结果，给Client相应的响应。

私钥是Server端独有，这就保证了Client的登录信息即使在网络传输过程中被窃据，也没有私钥进行解密，保证了数据的安全性，这充分利用了非对称加密的特性。

这样就一定安全了吗？上述流程会有一个问题：Client端如何保证接受到的公钥就是目标Server端的？，如果一个攻击者中途拦截Client的登录请求，向其发送自己的公钥，Client端用攻击者的公钥进行数据加密。攻击者接收到加密信息后再用自己的私钥进行解密，不就窃取了Client的登录信息了吗？这就是所谓的中间人攻击。

SSH中是如何解决这个问题的？

1.1 基于口令（密码）的认证

从上面的描述可以看出，问题就在于如何对 Server 的公钥进行认证？在https中可以通过CA来进行公证，可是SSH的 publish key 和 private key 都是自己生成的，没法公证。「则只能通过 Client 端自己对公钥进行确认」。通常在第一次登录时会出现如下提示信息：

The authenticity of host 'ssh-server.example.com (12.18.429.21)' can't be established. RSA key fingerprint is 98:2e:d7:e0:de:9f:ac:67:28:c2:42:2d:37:16:58:4d. Are you sure you want to continue connecting (yes/no)?
# 上面的信息说的是: 无法确认主机 ssh-server.example.com（12.18.429.21）的真实性，不过知道它的公钥指纹，是否继续连接？

之所以用 fingerprint 代替 key，主要是 key 过于长（RSA算法生成的公钥有1024位），很难直接比较。所以对公钥进行 hash 生成一个128位的指纹就方便比较了。

# 如果输入yes后，会出现下面信息：
Warning: Permanently added 'ssh-server.example.com, 12.18.429.21' (RSA) to the list of known hosts. Password: (enter password) 
# 该host已被确认，并被追加到文件known_hosts中，然后就需要输入密码，之后的流程就按照图1-3进行。

1.2 基于公钥（pubKey）的认证

在上面介绍的登录流程中可以发现，每次登录都需要输入密码，很麻烦。SSH 提供了另外一种可以免去输入密码过程的登录方式：公钥登录。流程如下：

1.Client将自己的公钥存放在Server上，追加在文件authorized_keys中。
2. Client 带着自己的 pubKey 请求 Server，Server端接收到Client的连接请求后，会在authorized_keys（即保存已授权的客户端公钥）中匹配到Client的公钥pubKey，并生成随机数R，用Client的公钥对该随机数进行加密得到pubKey®，然后将加密后信息发送给Client。
3.Client端通过私钥进行解密得到随机数R，然后对随机数R和本次会话的SessionKey利用MD5生成摘要Digest1，发送给Server端。
4.Server端会也会对R和SessionKey利用同样摘要算法生成Digest2。
5.Server端会最后比较Digest1和Digest2是否相同，完成认证过程。

在步骤1中，Client将自己的公钥存放在Server上。需要用户手动将公钥copy到server上。这就是在配置ssh的时候进程进行的操作。下图是GitHub上SSH keys设置视图：

在这里插入图片描述

二、SSH 实践

2.1 生成密钥操作

经过上面的原理分析，下面三行命令的含义应该很容易理解了：

ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
$ chmod 0600 ~/.ssh/authorized_keys

ssh-keygen是用于生产密钥的工具。
-t：指定生成密钥类型（rsa、dsa、ecdsa等）
-P：指定passphrase，用于确保私钥的安全
-f：指定存放密钥的文件（公钥文件默认和私钥同目录下，不同的是，存放公钥的文件名需要加上后缀.pub）
首先看下面~/.ssh中的四个文件：

1.id_rsa：保存私钥
2.id_rsa.pub：保存公钥
3.authorized_keys：保存已授权的客户端公钥
4.known_hosts：保存已认证的远程主机ID（关于known_hosts详情，见文末更新内容）

四个角色的关系如下图所示：

在这里插入图片描述
需要注意的是：一台主机可能既是Client，也是Server。所以会同时拥有authorized_keys和known_hosts。

2.2 登录操作

 以用户名user，登录远程主机host		$ ssh user@host
# 本地用户和远程用户相同，则用户名可省去	$ ssh host
# SSH默认端口22，可以用参数p修改端口		$ ssh -p 2017 user@host

三、known_hosts

known_hosts中存储的内容是什么？
known_hosts中存储是已认证的远程主机host key，每个SSH Server都有一个secret, unique ID, called a host key。
host key何时加入known_hosts的？
当我们第一次通过SSH登录远程主机的时候，Client端会有如下提示：

Host key not found from the list of known hosts.Are you sure you want to continue connecting (yes/no)?

此时，如果我们选择yes，那么该host key就会被加入到Client的known_hosts中，格式如下：

# domain name+encryption algorithm+host keyexample.hostname.com ssh-rsa AAAAB4NzaC1yc2EAAAABIwAAAQEA。。。

为什么需要known_hosts？
最后探讨下为什么需要known_hosts，这个文件主要是通过Client和Server的双向认证，从而避免中间人（man-in-the-middle attack）攻击，每次Client向Server发起连接的时候，不仅仅Server要验证Client的合法性，Client同样也需要验证Server的身份，SSH client就是通过known_hosts中的host key来验证Server的身份的。

这中方案足够安全吗？当然不，比如第一次连接一个未知Server的时候，known_hosts还没有该Server的host key，这不也可能遭到中间人攻击吗？这可能只是安全性和可操作性之间的折中吧。

四、sshpass

sshpass是一款自动为ssh填充密码的开源插件，并没有对ssh做任何修改，是从外部进行的操作。sshpass实现比较简单，但是非常易用，原理与expect类似。sshpass主函数源码只有500来行，在https://sourceforge.net/projects/sshpass/ 可以下载。

sshpass密码填充方式有三种，通过-p后边的参数将密码传送过去，读取文件第一行作为密码传过去，或者通过-e将名字为SSHPASS的环境变量作为密码传过去。源码如下：

void write_pass( int fd ) {
    switch( args.pwtype ) {
    case PWT_STDIN:   // 密码来自标准输入
    write_pass_fd( STDIN_FILENO, fd );
    break;
    case PWT_FD:     // 密码来自文件描述符
    write_pass_fd( args.pwsrc.fd, fd );
    break;
    case PWT_FILE:  //密码来自文件
    {
        int srcfd=open( args.pwsrc.filename, O_RDONLY );
        if( srcfd!=-1 ) {
        write_pass_fd( srcfd, fd );
        close( srcfd );
        }
    }
    break;
    case PWT_PASS:  //密码来自变量，使用-p或者SSHPAS环境变量
    write( fd, args.pwsrc.password, strlen( args.pwsrc.password ) );
    write( fd, "\n", 1 );
    break;
    }
}

在这里插入图片描述

当main函数开始执行，主进程执行masterpt=posix_openpt(O_RDWR);此时会有一个伪终端，然后fork（）出一个子进程，在子进程下执行ssh命令，当收到带有*assword关键词的输出时候讲密码填充进去。

使用方式如下:

sshpass 命令放在ssh命令之前，sshpass 与ssh分别将自己的命令参数放到自己后面。
sshpass "command params" ssh -o StrictKeyChecking root@192.168.2.99 "ssh's command params"
sshpass -p mypass ssh -o StrictKeyChecking root@192.168.2.99 "ls && pwd && ps -ef"

五、建立 SSH 免密脚本

过程是：

找到A机的pub文件cat ~/.ssh/id_rsa.pub
登到B机vim .ssh/authorized_keys 把那一行id_rsa.pub加进去, 就可以在A用ssh root@B登陆了

禁用密码登录

登到server, vim /root/.ssh/authorized_keys, 在其中改一行PasswordAuthentication no即可禁用密码登录
然后重启ssh /etc/init.d/ssh restart

5.1 create_sshkey.sh

先在每个机器建立秘钥

#!/bin/bash

RED="\033[31m"
YELLOW="\033[33m"
COLOR_END="\033[0m"

echo -e "${YELLOW}[开始] ${COLOR_END}"
if [ $UID != 0 ]; then
    echo -e "${RED}请使用root安装!${COLOR_END}" && exit 500
fi

# postgres
echo -e "${YELLOW}开始创建postgres用户 ${COLOR_END}"
POSTGRES_HOME_PATH="/var/lib/postgresql"
mkdir -p -m 750 ${POSTGRES_HOME_PATH}/.ssh
chown -R postgres:postgres ${POSTGRES_HOME_PATH}/.ssh
if [ ! -f "${POSTGRES_HOME_PATH}/.ssh/id_rsa" ] || [ ! -f "${POSTGRES_HOME_PATH}/.ssh/id_rsa.pub" ]; then
    echo -e "${YELLOW}开始创建新秘钥${COLOR_END}" && su - postgres -c "ssh-keygen -f ${POSTGRES_HOME_PATH}/.ssh/id_rsa -t rsa -b 4096 -N ''"
else
    echo -e "${YELLOW}秘钥已存在, 一切正常${COLOR_END}"
fi
(echo "postgres" && echo "postgres") | sudo passwd postgres

echo -e "${YELLOW}[结束] ${COLOR_END}"

5.2 sshcopy.sh

再用ssh-copy-id把自己的公钥发给别人

create_ssh_passwordless() {
    FUNC="建立ssh免密登录"
    echo -e "${YELLOW}[开始] ${FUNC} ${COLOR_END}"
    PRIMARY_POSTGRES_HOME_PATH="/var/lib/postgresql"
    case ${NODE_TYPE} in
    ${NODE_TYPE_PRIMARY})
        echo -e "${YELLOW}开始拷贝公钥${COLOR_END}" && sshpass -p postgres ssh-copy-id -o StrictHostKeyChecking=no -f -i ${PRIMARY_POSTGRES_HOME_PATH}/.ssh/id_rsa.pub postgres@${STANDBY_IP}
        echo -e "${YELLOW}开始建立第一次ssh连接${COLOR_END}" && su - postgres -c "ssh -o StrictHostKeyChecking=no postgres@${STANDBY_IP} hostname"
        ;;
    ${NODE_TYPE_STANDBY})
        sshpass -p postgres ssh-copy-id -o StrictHostKeyChecking=no -f -i ${PRIMARY_POSTGRES_HOME_PATH}/.ssh/id_rsa.pub postgres@${PRIMARY_IP}
        su - postgres -c "ssh -o StrictHostKeyChecking=no postgres@${PRIMARY_IP} hostname"
        ;;
    esac
    echo -e "${YELLOW}[结束] ${FUNC} ${COLOR_END}"
}

六、go:sftp远程传输文件+ssh执行命令

从本地向远程拷贝文件 or 从远程向本地拷贝文件

package services

import (
	"fmt"
	"github.com/pkg/sftp"
	log "github.com/sirupsen/logrus"
	"configs"
	"golang.org/x/crypto/ssh"
	"net"
	"os"
	"path"
	"time"
)

type sftpSSHService struct{}

func SFTPSSHService() *sftpSSHService {
	return &sftpSSHService{}
}

func (s *sftpSSHService) CopyLocalFileToRemote() {
	total := len(configs.SFTPHosts())
	log.Infof("start  copy file from local to remote server, total: %v", total)
	for i, host := range configs.SFTPHosts() {
		log.Infof("start  server: %v with %v/%v", host, i, total)
		sftpClient, sshSession, err := s.newSFTPAndSSH(configs.SFTPUserName(), configs.SFTPPassword(), host, configs.SFTPPort())
		if err != nil {
			log.Error(err)
			continue
		}
		defer sftpClient.Close()

		// 将本地文件 sftp 到远程机器上
		var localFilePath = configs.SFTPFileName()
		var remoteDir = configs.SFTPRemoteDir()
		srcFile, err := os.Open(localFilePath)
		if err != nil {
			log.Error(err)
			continue
		}
		defer srcFile.Close()
		remoteFileName := path.Base(localFilePath)
		dstFile, err := sftpClient.Create(path.Join(remoteDir, remoteFileName))
		if err != nil {
			log.Error(err)
			continue
		}
		defer dstFile.Close()
		if _, err = dstFile.ReadFrom(srcFile); err != nil {
			log.Error(err)
			continue
		}

		// 执行ssh命令
		for _, cmdStr := range configs.SFTPCommands() {
			if err := sshSession.Run(cmdStr); err != nil {
				log.Error(err)
			}
		}

		log.Infof("finish server: %v with %v/%v", host, i, total)
	}
	log.Infof("finish copy file from local to remote server, total: %v", total)
}

func (s *sftpSSHService) newSFTPAndSSH(user, password, host string, port int) (*sftp.Client, *ssh.Session, error) {
	clientConfig := &ssh.ClientConfig{ // get auth method
		User:            user,
		Auth:            []ssh.AuthMethod{ssh.Password(password)},
		Timeout:         30 * time.Second,
		HostKeyCallback: func(string, net.Addr, ssh.PublicKey) error { return nil },
	}
	addr := fmt.Sprintf("%s:%d", host, port)
	sshClient, err := ssh.Dial("tcp", addr, clientConfig) // connect to ssh
	if err != nil {
		return nil, nil, err
	}
	sftpClient, err := sftp.NewClient(sshClient)
	if err != nil {
		return nil, nil, err
	}
	sshSession, err := sshClient.NewSession()
	if err != nil {
		return nil, nil, err
	}
	return sftpClient, sshSession, nil
}