golang实现远程控制主机

ssh原理

说到ssh原理个人觉得解释最全的一张图是这张华为画的

Connection establishment
这一步就是建立tcp连接
version negotiation
这一步是ssh客户端(连接者)和被ssh服务端(连接者)进行协议的交换，比如ssh客户端支持那些加密协议，协商出最后使用的协议，还有就是协商ssh版本

Key Exchange
在说Key Exchange之前，我们要知道主机有2类的ssh-key分别是hostkey和user ssh key，每类key都分公钥和私钥，公钥可以加密，私钥可以解密

• hostkey：

• user ssh key：

首先hostkey，当ssh server安装的时候这个hostkey就会默认生成，在第一次连接对端的时候会显示的提醒我们叫我们确认时候继续连接如下

The authenticity of host '192.168.152.132 (192.168.152.132)' can't be established.
ECDSA key fingerprint is SHA256:MzAmI+qRcIEb0AS+6XMcAH5gtxnB779KpHRa1vOvAMs.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes	 

这是啥意思呢我们第一次连接ssh服务端，服务段会发送自己的hostkey的hash后的值给我们，我们如果选择yes，这段hash后的ssh服务端的hostkey被存入本地的.ssh/know_hosts中这是为了防止中间人攻击，有了这个hostkey之后，会使用diffie-hellman，这个算法用于为2端同时生成session key，因为diffie-hellman算法的特新session key必定相等，后续session建立后都会用这个session key进行加密传输

Key Authentication
随后是user ssh key，这个东西是用户用ssh-keygen生成的(也是ssh -i指定的identity_file])，当用户使用key认证而非密码认证的时候，这个就非常重要，ssh客户端将自己的public user ssh key发送给服务端(因为是session，用session可以进行加密)，然后每当ssh客户端登录到服务端都会自己生成一个随机数用user 自己的userprivate key进行加密通过session传递给客户端，服务端再用接收客户端的公钥进行解密再发送回客户端，客户端进行check，是自己刚刚生成的key就发送验证成功的消息给服务端，最后验证通过，每当客户端向服务端进行数据传输都会使用之前的session key进行加密，服务段接收后用相同的session key进行解密

golang

package main

import (
        "fmt"
        "log"
        "os"

        "golang.org/x/crypto/ssh"
        "golang.org/x/crypto/ssh/knownhosts"
        //"golang.org/x/cryto/ssh"
)

func main() {
        //用于对方返回的key
        hostkey, err := knownhosts.New("/root/.ssh/known_hosts")
        if err != nil {
                log.Fatal("get knowhosts file error: %s", err.Error())
        }

        identify_file := "/root/.ssh/ansible"
        addr := "192.168.152.132:22"

        key, err := os.ReadFile(identify_file)
        if err != nil {
                log.Fatal("error,Can not Read file " + identify_file + " : " + err.Error())
        }

        //将私钥用PEM方式加密返回成签名
        signer, err := ssh.ParsePrivateKey(key)
        if err != nil {
                log.Fatal("unbale to parseprivatekey: ", err)
        }

        //设置连接peer时候的config
        config := &ssh.ClientConfig{
                User: "root",
                Auth: []ssh.AuthMethod{
                        ssh.PublicKeys(signer),
                },
                HostKeyCallback: hostkey,
        }

        //连接(key exchange,这里exhcange的是host key，用于认证session，而user key也就是自己手动生成的key用于验证用户)
        client, err := ssh.Dial("tcp", addr, config)
        if err != nil {
                log.Fatal("unable to connect: " + err.Error())
        }

        defer client.Close()

        session, err := client.NewSession()
        if err != nil {
                log.Fatal("new session error: %s", err.Error())
        }

        result, _ := session.Output("ip a")
        if err != nil {
                fmt.Fprintf(os.Stderr, "faile to run command, err:%s", err.Error())
        }

        fmt.Println(string(result))

}

代码非常简单，注意我们如果是第一次连接那么上述代码会执行失败，因为第一次连接，ssh server要返回自己的hostkey给客户端(我们执行代码的机器)，客户端要在自己的know_host里面check，但是第一次连接know_host没有数据就会失败，所以可以将代码改成不安全的模式，也就是不check know_host，方法也很简单，就是将连接时候的config的HostKeyCallback对应的值改为ssh.InsecureIgnoreHostKey()如下

package main

import (
        "fmt"
        "log"
        "os"

        "golang.org/x/crypto/ssh"
        //"golang.org/x/crypto/ssh/knownhosts"
        //"golang.org/x/cryto/ssh"
)

func main() {
        //用于对方返回的key
        //hostkey, err := knownhosts.New("/root/.ssh/known_hosts")
        //if err != nil {
        //      log.Fatal("get knowhosts file error: %s", err.Error())
        //}

        identify_file := "/root/.ssh/ansible"
        addr := "192.168.152.132:22"

        key, err := os.ReadFile(identify_file)
        if err != nil {
                log.Fatal("error,Can not Read file " + identify_file + " : " + err.Error())
        }

        //将私钥用PEM方式加密返回成签名
        signer, err := ssh.ParsePrivateKey(key)
        if err != nil {
                log.Fatal("unbale to parseprivatekey: ", err)
        }

        //设置连接peer时候的config
        config := &ssh.ClientConfig{
                User: "root",
                Auth: []ssh.AuthMethod{
                        ssh.PublicKeys(signer),
                },
                HostKeyCallback: ssh.InsecureIgnoreHostKey(),
        }

        //连接(key exchange,这里exhcange的是host key，用于认证session，而user key也就是自己手动生成的key用于验证用户)
        client, err := ssh.Dial("tcp", addr, config)
        if err != nil {
                log.Fatal("unable to connect: " + err.Error())
        }

        defer client.Close()

        session, err := client.NewSession()
        if err != nil {
                log.Fatal("new session error: %s", err.Error())
        }

        result, _ := session.Output("ip a")
        if err != nil {
                fmt.Fprintf(os.Stderr, "faile to run command, err:%s", err.Error())
        }

        fmt.Println(string(result))

}

最后打印出结果

root@master:~/demo/ssh# ./ssh
1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: ens32:  mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:7e:76:1b brd ff:ff:ff:ff:ff:ff
    altname enp2s0
    inet 192.168.152.132/24 brd 192.168.152.255 scope global noprefixroute ens32
       valid_lft forever preferred_lft forever
    inet6 fe80::20c:29ff:fe7e:761b/64 scope link
       valid_lft forever preferred_lft forever