gossh

package module
v0.0.0-...-f2350ca Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 4, 2022 License: Apache-2.0 Imports: 19 Imported by: 1

README

Make SSH Client Easier With GO

本包对 golang.org/x/crypto/ssh 中的客户端相关类型进行了简单的包装，一般的使用者能够通过较少的代码量快速实现一个可正常使用的 SSH 客户端应用程序。

目前只提供了部分功能，后续会补上一些常用的 subsystem 的工具实现，例如 sftp 等。 更多用法请看 https://pkg.go.dev/github.com/nishoushun/gossh

安装
go get github.com/nishoushun/gossh
go get github.com/nishoushun/gossh/cli
shell & exec

构建一个 Config，通过 Connect 函数获取一个 SSHClient 实例，然后使用。

shell

连接一个 Shell 只需要以下几步：

  1. 创建一个 Config 实例；Config 类型包含了 ssh.Config 与 ssh.ClientConfig 的所有字段，用于配置客户端以及连接的选项；
  2. 调用 Connect 函数建立 SSH 连接，并获取一个 SSHClient 实例；
  3. 用获取的 SSHClient 实例，调用 OpenSession 打开一个新的会话；
  4. MakeRow 函数禁用标准输入的回显以及行缓；
  5. 发送一个 pty-req 请求，附带上你的终端色彩模式；
  6. 绑定会话的输入输出至本地；
  7. 请求 shell，直至 exit-status 被接收；

以下示例以 Open-SSH 作为服务端.

示例 1：连接至目标机器的 shell

package main

import (
	"fmt"
	"github.com/nishoushun/gossh"
	"log"
	"os"
)

func main() {
	client, err := gossh.Connect(":22", gossh.DefaultConfigAuthByPasswd("niss", "123456"))
	if err != nil {
		log.Fatalln(err)
	}
	sess, err := client.OpenSession()
	cancelRow, _ := sess.MakeRow(os.Stdin)
	defer cancelRow()
	cancelUpdate, _ := sess.AutoUpdateTerminalSize()
	defer cancelUpdate()
	err = sess.PreparePty("xterm-256color")
	if err != nil {
		log.Fatalln(err)
	}
	sess.RedirectToSTD()
	err = sess.Shell()
	if err != nil {
		fmt.Println(err)
	}
}

编译并运行即可进入 SSH Shell：

image-20220501210651432

远程命令执行

相对于 shell 来说，远程命令执行要简单的多。打开一个新的会话后，只需要执行 RunForCombineOutput 即可等待命令执行完毕，并返回执行结果。

示例 2：执行远程命令 ls / -al

package main

import (
	"fmt"
	"github.com/nishoushun/gossh"
	"log"
)

func main() {
	client, err := gossh.Connect(":22", gossh.DefaultConfigAuthByPasswd("niss", "123456"))
	if err != nil {
		log.Fatalln(err)
	}
	sess, err := client.OpenSession()
	output, err := sess.RunForCombineOutput("ls / -al")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(output))
}

image-20220501211528455

另外本包也支持像执行 shell 一样执行一个交互式远程命令。

示例 3：执行 htop 类型的交互式命令

package main

import (
	"fmt"
	"github.com/nishoushun/gossh"
	"log"
	"os"
)

func main() {
	client, err := gossh.Connect(":22", gossh.DefaultConfigAuthByPasswd("niss", "123456"))
	if err != nil {
		log.Fatalln(err)
	}
	sess, err := client.OpenSession()
	cancelRow, _ := sess.MakeRow(os.Stdin)
	defer cancelRow()
	cancelUpdate, _ := sess.AutoUpdateTerminalSize()
	defer cancelUpdate()
	sess.RedirectToSTD()
	err = sess.RunWithPty("htop", "xterm-256color")
	if err != nil {
		fmt.Println(err)
	}
}

image-20220501212206859

端口转发

对于端口转发功能，原有的 ssh 包也提供了相应的 Dial 与 Listen 来实现相应的功能。但不同于命令执行，这需要写代码的人员了解 SSH 协议的 direct-tcpip 以及 tcpip-forward 类型的 ssh channel 的机制。

Dial 通过已经建立 ssh 的连接，请求一个新的信道来连接至远程端口，并返回一个 net.Conn 接口的实现，本质上是 direct-tcpip 请求；

Listen 通过已经建立 ssh 的连接，让服务端监听一个端口，并且其连接都将转发至本地客户端，因此 Listen 会返回一个 net.Listener 来接受转发的网络连接。

也就是说，原有 ssh 包已经实现了两种转发功能，而且上述两种方法也同样被包装进 SSHClient 类型中。

Director

Director 提供了一些数据传送的函数，来简化端口转发的操作过程。其本质上是 direct-tcpip 信道的处理，即对 Dial 以及 DialTcp 函数的更高级封装。

通过 SSHClient 的 NewDirector 创建一个该类型实例。

示例 4：转发本地连接至远程服务器

由于没有远程服务器，先用 docker 凑合一下。没有设置端口映射，如果需要访问web服务，要通过 172.17.0.2:80

image-20220502180620629

访问本地地址无法访问 web 服务：

image-20220502181005228

使用 172.17.0.2:80 访问：

image-20220502181027352

下面代码展示了如何转发单个网络连接（TCP连接）的数据：

package main

import (
	"fmt"
	"github.com/nishoushun/gossh"
	"log"
	"net"
	"os"
	"os/signal"
)

func main() { 
	client, err := gossh.Connect("127.0.0.1:22", gossh.DefaultConfigAuthByPasswd("niss", "123456"))
	if err != nil {
		log.Fatalln("ssh failed:", err)
		return
	}
	network := "tcp"
	listener, err := net.Listen(network, "127.0.0.1:80")
	if err != nil {
		log.Fatalln("listen failed:", err)
		return
	}
	ctx, cancel := context.WithCancel(context.Background())
	c, _ := listener.Accept()
	client.NewDirector().BindConnTo(c, "tcp", "172.17.0.2:80", ctx, ctx)
}

这里读写用了同一个 context 进行控制，实际上可以用两个 context 分别控制 本地连接->远程服务端的连接 以及 远程服务端的连接->本地连接 的数据传输。

编译并运行，访问 127.0.0.1:80 可成功转发该 TCP 连接至 172.17.0.2:80：

image-20220502181620361

其实也可以发现，虽然只转发一条 tcp 连接，但是可以 F5 刷新多次，是由于 HTTP 的 Conntection: keep-alive 复用了同一个 TCP 连接。

稍微修改一下包装一下传入的 conn，使其 read 函数将数据输出至标准输出流，可以看到浏览器发送的数据：

image-20220502195459311

示例 4：监听端口，并转发本地连接至远程服务器

import (
	"fmt"
	"github.com/nishoushun/gossh"
	"golang.org/x/net/context"
	"log"
	"net"
	"os"
	"os/signal"
)

func main() {
	client, err := gossh.Connect("127.0.0.1:22", gossh.DefaultConfigAuthByPasswd("niss", "123456"))
	if err != nil {
		log.Fatalln("ssh failed:", err)
		return
	}
	network := "tcp"
	listener, err := net.Listen(network, "127.0.0.1:80")
	if err != nil {
		log.Fatalln("listen failed:", err)
		return
	}
	ctx, cancel := context.WithCancel(context.Background())
	client.NewDirector().RedirectTo(listener, network, "172.17.0.2:80", ctx)
}

注意：无论是 cancelFunc 的调用、 IO 错误，还是正常的传输完毕，都将导致两个网络连接被关闭。

NewConnCallback

另外 Director 也拥有一个 NewConnCallback func(conn net.Conn) (net.Conn, error) 类型的字段，在 RedirectTo 方法中当 listener 接收到一个新的连接，该函数将被调用，如果返回的 error 不为 nil，将终止本次转发过程。

该函数目的在于对一个新的连接进行记录、检查以及对 net.Conn 接口实例进行转换，以支持更多功能。

客户端 Demo

cli 包下面实现了一个基础的客户端 Demo，本 Demo 只实现了一个简单的 shell 以及 命令执行请求，后续可能会补上 SSHClient 的 sftp 以及一些其它功能。

image-20220327032755721

编译 & 运行

cli 包下包含了一个 Run 方函数，用于执行一个很简单的 SSH 客户端 demo，只需要导入包，编译后就可运行：

package main

import "github.com/nishoushun/gossh/cli"

func main() {
	cli.Run()
}
Usage
➜  ssh ./ssh --help             
usage: ssh [<flags>] <command> [<args> ...]

Flags:
      --help                     Show context-sensitive help (also try --help-long and --help-man).
  -p, --port="22"                port of ssh host.
  -h, --host=HOST                the host address of ssh host, ip address or domain name.
  -u, --user="niss"              specified user to login.
  -e, --env=ENV ...              set environment.
      --display-banner           display server banner.
  -k, --private-key="/home/niss/.ssh/id_rsa"  
                                 use specified private key file.
  -a, --ssh-agent                use ssh-agent for authentication.
  -P, --passwd                   force to use password.
      --known-hosts="/home/niss/.ssh/known_hosts"  
                                 use specified known hosts file.
  -t, --timeout=0s               timeout for connection.
  -z, --term="xterm-256color"    use the given terminal-color mod to run the interactive command line or shell.
  -l, --keep-alive               send useless request to keep tcp connection alive.
  -i, --keep-alive-interval=60s  set the interval of keepalive request.
      --ignore-host-key          do not check the server's host key.
      --cipher=CIPHER ...        choose cipher algorithm
      --key-exchange=KEY-EXCHANGE ...  
                                 choose key exchange algorithm
      --mac=MAC ...              choose message authentication code algorithm
      --rand=RAND                choose a src to read random bytes
      --version                  Show application version.

Commands:
  help [<command>...]
    Show help.

  exec [<flags>] <command line>
    execute command.

  shell
    Run remote shell based on ssh protocol.

  version
    show the version.
创建ssh终端

Peek 2022-03-27 03-32

命令执行

Peek 2022-03-27 03-37

交互式执行命令

本客户端可以获取伪终端，并能检测本地终端大小的变化，同步到远程终端：

Peek 2022-03-27 03-45

身份验证
  • -P：使用密码验证
  • -a, --ssh-agent：使用ssh-agent验证
  • -k, --private-key：私钥文件路径（默认为 ～/.ssh/id_rsa）
  • --known-hosts：known_hosts 文件路径（默认为 ～/.ssh/known_hosts ）
密码算法组件选项

  • --cipher：选取加密算法

    支持：aes128-ct、aes192-ctr、aes256-ctr、aes128-gcm@openssh.com、chacha20-poly1305@openssh.com、arcfour256、arcfour128、arcfour、aes128-cbc、3des-cbc

  • --key-exchange：选取密钥交换算法

    支持：curve25519-sha256、curve25519-sha256@libssh.org、ecdh-sha2-nistp256、ecdh-sha2-nistp384、ecdh-sha2-nistp521、diffie-hellman-group14-sha256、diffie-hellman-group14-sha1、diffie-hellman-group1-sha1

  • --mac：选取消息摘要算法

    支持：ssh-rsa、rsa-sha2-256、rsa-sha2-512、ssh-dss、ecdsa-sha2-nistp256、ecdsa-sha2-nistp384、ecdsa-sha2-nistp521、sk-ecdsa-sha2-nistp256@openssh.com、sk-ssh-ed25519@openssh.com

    该系列选项可以通过多次指定以添加多个算法，例如：

    gossh connect --cipher aes128-ctr --cipher aes256-ctr

  • --rand：要使用的随机数源，在linux系统中默认为 /dev/urandom

Documentation

Index

Constants

View Source 
const (
	OpenSSHPrivateKeyPathPath = ".ssh/id_rsa"
	OpenSSHKnownHostsPath     = ".ssh/known_hosts"
)

Variables

This section is empty.

Functions

func AuthByPrivateKeys 

func AuthByPrivateKeys(keys ...[]byte) (ssh.AuthMethod, error)

func AuthByPrivateKeysFromPaths 

func AuthByPrivateKeysFromPaths(files ...string) (ssh.AuthMethod, error)

AuthByPrivateKeysFromPaths 从给定的文件中加载私钥并生成 Signer，并生成 ssh.AuthMethod 认证方法. 任何一个文件解析失败都将返回一个不为 nil 的错误

func CopyBufferWithContext 

func CopyBufferWithContext(dst io.Writer, src io.Reader, buf []byte, ctx context.Context) (written int64, err error)

CopyBufferWithContext 导出的 io.copyBuffer 函数，可传入 Context 对应的 cancelFunc 来终止流之间的复制，并返回 nil error

func CurrentUser 

func CurrentUser() string

CurrentUser 当前的的用户名

func DisplayBanner 

func DisplayBanner(message string) error

DisplayBanner 简单地打印服务器发送的 banner 信息

func IgnoreHostKey 

func IgnoreHostKey(hostname string, remote net.Addr, key PublicKey) error

IgnoreHostKey 忽略主机公钥，总是返回 nil error

func KnownHostsPath 

func KnownHostsPath(username string) (string, error)

KnownHostsPath 获取给定用户的默认的 Open-SSH known_hosts 路径

func NewFixHostKeyCallback 

func NewFixHostKeyCallback(key []byte) (func(hostname string, remote net.Addr, key ssh.PublicKey) error, error)

NewFixHostKeyCallback 用于固定主机公钥的主机验证方式

func NewKnownHostCallback 

func NewKnownHostCallback(interactively bool, files ...string) func(hostname string, remote net.Addr, key PublicKey) error

NewKnownHostCallback 生成一个known_host callback

func PrivateKeyPath 

func PrivateKeyPath(username string) (string, error)

PrivateKeyPath 获取给定用户的默认的 Open-SSH 私钥路径

func WrapAuthMethodSlice 

func WrapAuthMethodSlice(methods []AuthMethod) []ssh.AuthMethod

func WrapBannerCallback 

func WrapBannerCallback(callback BannerCallback) func(message string) error

WrapBannerCallback WrapHostKeyCallback 将 BannerCallback 转化为 ssh 包可接受参数类型

func WrapHostKeyCallback 

func WrapHostKeyCallback(callback HostKeyCallback) func(hostname string, remote net.Addr, key ssh.PublicKey) error

WrapHostKeyCallback 将 HostKeyCallback 转化为 ssh 包可接受参数类型

Types

type AuthMethod 

type AuthMethod interface {
	ssh.AuthMethod
}

func KeyboardInteractive 

func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod

KeyboardInteractive 返回一个 AuthMethod

func PasswordAuth 

func PasswordAuth(passwd string) AuthMethod

PasswordAuth 由给定的密码进行认证

func ReadPasswordAuth 

func ReadPasswordAuth(prompt ...string) (AuthMethod, error)

ReadPasswordAuth 从标准输入中获取输入密码进行认证 prompt 为输入前的字符提示；

func RetryableAuthMethod 

func RetryableAuthMethod(auth AuthMethod, maxTries int) AuthMethod

RetryableAuthMethod 是其他 auth 方法的装饰器，使它们能够在考虑 AuthMethod 本身失败之前重试到 maxTries。如果 maxTries <= 0，将无限期重试

func SSHAgentAuth 

func SSHAgentAuth() (AuthMethod, error)

SSHAgentAuth ssh-agent 身份验证

type BannerCallback 

type BannerCallback func(message string) error

type Channel 

type Channel interface {
	ssh.Channel
}

type Config 

type Config struct {
	Rand           io.Reader // 随机数源
	RekeyThreshold uint64    //
	KeyExchanges   []string  // 密钥交换算法算法
	Ciphers        []string  // 加密算法
	MACs           []string  // 消息摘要算法

	User              string          // 登陆用户
	Auth              []AuthMethod    // 身份验证方法列表
	HostKeyCallback   HostKeyCallback // 服务端主机公钥验证
	BannerCallback    BannerCallback  // 身份认证前对服务端发送的 Banner 信息的处理。注意，并不是所有的服务端都会发送该信息
	ClientVersion     string          // 必须以 'SSH-1.0-' 或者 'SSH-2.0-' 开头，如果为空，将被替换为 'SSH-2.0-GoSSH'
	HostKeyAlgorithms []string
	Timeout           time.Duration // 建立 tcp 连接超时时间
}

Config ssh 包下的 ClientConfig 的包装

func DefaultConfigAuthByAgent 

func DefaultConfigAuthByAgent(user string) (*Config, error)

DefaultConfigAuthByAgent 生成默认的配置，认证方式为 ssh-agent 认证。 不会主机公钥验证，需要后续添加 HostKeyCallback； user 为登陆用户名

func DefaultConfigAuthByPasswd 

func DefaultConfigAuthByPasswd(user, password string) *Config

DefaultConfigAuthByPasswd 生成默认的配置，认证方式为密码认证。 不会主机公钥验证，需要后续添加 HostKeyCallback； user 为登陆用户名，password 为登陆密码

func DefaultConfigAuthByPrivateKey 

func DefaultConfigAuthByPrivateKey(user string, keys ...[]byte) (*Config, error)

DefaultConfigAuthByPrivateKey 生成默认的配置，认证方式为私钥认证。 不会主机公钥验证，需要后续添加 HostKeyCallback； user 为登陆用户名，keys 为多个私钥文件的内容

func DefaultConfigAuthByPrivateKeyFromPaths 

func DefaultConfigAuthByPrivateKeyFromPaths(user string, path ...string) (*Config, error)

DefaultConfigAuthByPrivateKeyFromPaths 生成默认的配置，认证方式为私钥认证。 不会主机公钥验证，需要后续添加 HostKeyCallback； user 为登陆用户名，keys 为多个私钥文件的路径

type Director 

type Director struct {
	NewConnCb NewConnCallback
	// contains filtered or unexported fields
}

func (*Director) BindConnTo 

func (d *Director) BindConnTo(lconn net.Conn, netType, addr string, rctx, wctx context.Context) error

BindConnTo 与 BindConnToWithBuffer 相同，但使用默认的 buf

func (*Director) BindConnToWithBuffer 

func (d *Director) BindConnToWithBuffer(lconn net.Conn, netType, addr string, bufSize int, rctx, wctx context.Context) error

BindConnToWithBuffer 通过已经建立的 SSH 连接，打开并连接至远程端口，并与给定的流之间进行数据复制，复制时使用给定的 bufSize。 rctx 用于控制远程连接至本地连接的数据传输的 Deadline 以及 cancelFunc 终止控制； wctx 用于控制本地连接至远程连接的数据传输的 Deadline 以及 cancelFunc 终止控制； 如果出现 IO 问题而不是 context 取消执行而导致的错误，双方网络连接将会被关闭 返回 error 不为 nil 表明远程网络连接未成功建立

func (*Director) BindTcpConnTo 

func (d *Director) BindTcpConnTo(lconn net.Conn, origin, to *net.TCPAddr, rctx, wctx context.Context) error

BindTcpConnTo 与 BindConnToWithBuffer 相同，但使用默认的 buf

func (*Director) BindTcpConnToWithBuffer 

func (d *Director) BindTcpConnToWithBuffer(lconn net.Conn, origin, to *net.TCPAddr, bufSize int, rctx, wctx context.Context) error

BindTcpConnToWithBuffer 与 BindConnToWithBuffer 相似，但只能用于 TCP 连接。 origin 表示源地址以及端口，如果 origin 为 nil, 将被零值（0.0.0.0:0）取代； to 表示要发送至远程服务器的地址以及端口； 返回 error 不为 nil 表明网络连接未成功建立。

func (*Director) DirectTcpToWithBuffer 

func (d *Director) DirectTcpToWithBuffer(listener net.Listener, to *net.TCPAddr, bufSize int, ctx context.Context)

DirectTcpToWithBuffer 通过传入的网络监听器接受网络连接，并尝试通过 direct-tcpip 信道打开一个远程端口并开始双向地复制数据。 将会阻塞，直至 Listener.Accept 返回的 err 不为 nil。 通过传入 Context 来控制 Deadline、终止监听以及终止流的复制。

func (*Director) RedirectTcpTo 

func (d *Director) RedirectTcpTo(localL net.Listener, netType, addr string, ctx context.Context)

RedirectTcpTo 与 RedirectTcpToWithBuffer 作用相同，但使用默认的 buffer size

func (*Director) RedirectTo 

func (d *Director) RedirectTo(localL net.Listener, netType, toAddr string, ctx context.Context)

RedirectTo 与 RedirectToWithBuffer 作用相同，但使用默认的 buffer size

func (*Director) RedirectToWithBuffer 

func (d *Director) RedirectToWithBuffer(listener net.Listener, netType, addr string, bufSize int, ctx context.Context)

RedirectToWithBuffer 通过传入的网络监听器接受网络连接，并尝试通过 direct-tcpip 信道打开一个远程端口并开始双向地复制数据。 将会阻塞，直至 Listener.Accept 返回的 err 不为 nil。 通过传入 Context 来控制 Deadline、终止监听以及终止流的复制。

type HostKeyCallback 

type HostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error

type KeyboardInteractiveChallenge 

type KeyboardInteractiveChallenge func(name, instruction string, questions []string, echos []bool) (answers []string, err error)

KeyboardInteractiveChallenge 应该打印服务端问题，可选择禁用回显（例如密码），并返回所有答案。 KeyboardInteractiveChallenge 可以在单个会话中被多次调用。 认证成功后，服务器可以发送一个不带问题的挑战，应打印名称和指令消息。 RFC 4256 第 3.3 节详细说明了 UI 在 CLI 和 GUI 环境中的行为方式。

type KnownHostsChecker 

type KnownHostsChecker struct {
	Interactively bool
	// contains filtered or unexported fields
}

func (KnownHostsChecker) KnownHostsCheck 

func (kw KnownHostsChecker) KnownHostsCheck(hostname string, remote net.Addr, key PublicKey) error

KnownHostsCheck 对 hostname 、remote 与 key 进行 known_hosts 匹配。 如果接收器的 interactively 为 true，将会以交互式方式询问是否接受此次连接，并将

type NewChannel 

type NewChannel interface {
	ssh.NewChannel
}

type NewConnCallback 

type NewConnCallback func(conn net.Conn) (net.Conn, error)

type PublicKey 

type PublicKey interface {
	ssh.PublicKey
}

type SSHClient 

type SSHClient struct {
	ssh.Conn
	sync.Mutex
	// contains filtered or unexported fields
}

SSHClient 对 ssh.Client 的一层包装

func Connect 

func Connect(addr string, config *Config) (*SSHClient, error)

Connect 使用提供的配置选项与目标建立 SSH 连接

func (*SSHClient) Client 

func (client *SSHClient) Client() *ssh.Client

Client 获取原始的 ssh.Client

func (*SSHClient) Dial 

func (client *SSHClient) Dial(netType, addr string) (net.Conn, error)

Dial 发送 direct-tcpip 通道建立请求，通过已经建立的 SSH 连接，连接至远程端口。 netType 为网络类型 tcp、tcp4、tcp6 以及 unix 之一； addr 应为远程服务端可访问的网络接口。 一个经典的应用就是 Open-SSH 的 ssh -L 端口转发

func (*SSHClient) DialTCP 

func (client *SSHClient) DialTCP(netType string, laddr, raddr *net.TCPAddr) (net.Conn, error)

DialTCP 发送 direct-tcpip 通道建立请求，通过已经建立的 SSH 连接，建立TCP连接至远程端口。 netType 为网络类型 tcp、tcp4、tcp6 之一； laddr 表示 tcp 请求来源，如果为 nil，将使用 '0.0.0.0:0'；raddr 为远程服务端可访问的地址以及端口

func (*SSHClient) Listen 

func (client *SSHClient) Listen(netType, addr string) (net.Listener, error)

Listen 发送 tcpip-forward 通道建立请求，通过本次建立的 SSH 信道，任何对 SSH 服务器上目标地址端口的访问都将被转发至本地， 从而监听远程系统端口。 netType 为网络类型 tcp、tcp4、tcp6 以及 unix 之一。 一个最经典的应用就是 Open-SSH 的 ssh -R 端口转发，发送至远程目标端口的连接与数据都将被转发至返回的监听器。

func (*SSHClient) ListenTcp 

func (client *SSHClient) ListenTcp(laddr *net.TCPAddr) (net.Listener, error)

ListenTcp 类似于 Listen ，但是监听远程系统的 Tcp 端口，返回监听器，

func (*SSHClient) ListenUnix 

func (client *SSHClient) ListenUnix(socketPath string) (net.Listener, error)

ListenUnix 类似于 Listen ，监听远程 unix 系统的 unix socket

func (*SSHClient) NewDirector 

func (client *SSHClient) NewDirector() *Director

NewDirector 创建一个 Director

func (*SSHClient) OpenChannel 

func (client *SSHClient) OpenChannel(name string, extraData []byte) (Channel, <-chan *ssh.Request, error)

OpenChannel 请求建立一个新的 ssh 通道

func (*SSHClient) OpenSession 

func (client *SSHClient) OpenSession() (*Session, error)

OpenSession 打开一个新的 session 通道

type Session 

type Session struct {
	sync.Mutex
	// contains filtered or unexported fields
}

Session 对 ssh.Session 的一个包装，提供了 session 通道的处理工具函数。 对于同一个 Session 实例，任何命令或 shell 的只能执行1次，当收到服务器的 exit-status 消息时，底层的通道将被关闭。 对于绝大部分 SSH 服务器，shell、命令执行都不存在问题，但是环境变量以及信号的请求可能会限制于服务器的具体实现。

func (*Session) AutoUpdateTerminalSize 

func (s *Session) AutoUpdateTerminalSize() (context.CancelFunc, error)

AutoUpdateTerminalSize 自动检测窗口变化，并发送给服务端实现远程终端大小的同步。 使用返回的 CancelFunc 取消同步。 如果返回的 error 不为 nil，表明无法获取终端大小。 注意：此函数并不适用于 windows 系统，请用 AutoUpdateTerminalSizeForWindowsOS。

func (*Session) AutoUpdateTerminalSizeForWindowsOS 

func (s *Session) AutoUpdateTerminalSizeForWindowsOS(interval time.Duration) (context.CancelFunc, error)

AutoUpdateTerminalSizeForWindowsOS 适用于 Windows 系统的窗口变化自动检测并同步。 interval 为两次检测之间的时间间隔

func (*Session) Close 

func (s *Session) Close() error

func (*Session) Exec 

func (s *Session) Exec(cmdline string) error

Exec Shell 发送一个 exec 请求，并阻塞至 exit-status 消息被接收

func (*Session) KeepAlive 

func (s *Session) KeepAlive(interval time.Duration, maxErrRetries int) context.CancelFunc

KeepAlive 以 interval 为间隔发送请求，保持连接不被中断，这取决于服务器的网络设计以及 SSH 服务请求处理的实现。 当没有成功受到发送的请求的回应次数达到 maxErrRetries 时，将会停止并退出。 maxErrRetries 小于等于 0 时将会一直发送，直至返回函数被调用或出现IO错误。

func (*Session) MakeRow 

func (s *Session) MakeRow(input *os.File) (func() error, error)

MakeRow makeRow 禁用输入缓存，若禁用成功，返回恢复函数；否则返回 error 不为 nil 如果恢复函数执行结果为 error 不为 nil,则表明无法恢复文件的原有模式

func (*Session) PreparePty 

func (s *Session) PreparePty(termMode string) error

PreparePty 发送一个 pty-req 请求，附带的窗口大小信息从当前的标准输出文件中获取。 termMode 为 终端色彩模式

func (*Session) PreparePtyWithSize 

func (s *Session) PreparePtyWithSize(termMode string, termWidth, termHeight int) error

PreparePtyWithSize 发送一个指定窗口大小的 pty-req 请求。

func (*Session) RedirectInput 

func (s *Session) RedirectInput(in io.Reader) error

RedirectInput 重定向 in 至 session 的输入，返回的 error 不为 nil 表明无法正确地从 session 中获取输入流。

func (*Session) RedirectOutput 

func (s *Session) RedirectOutput(out, err io.Writer) error

RedirectOutput 重定向 session 的输出，返回的 error 不为 nil 表明无法正确地从 session 中获取输出流。

func (*Session) RedirectToSTD 

func (s *Session) RedirectToSTD() error

RedirectToSTD 重定向 session 的输入、输出至当前程序的标准输入、输出。

func (*Session) RunForCombineOutput 

func (s *Session) RunForCombineOutput(command string) ([]byte, error)

RunForCombineOutput 执行命令并等待至结束，返回远程执行结果的全部的输出。

func (*Session) RunForOutput 

func (s *Session) RunForOutput(command string) ([]byte, error)

RunForOutput 执行命令并等待至结束，返回远程执行结果的全部的标准输出。

func (*Session) RunWithPty 

func (s *Session) RunWithPty(command, termMode string) error

RunWithPty 先发送 pty-req 请求（窗口大小为当前终端的窗口大小），之后会发送一个 exec 请求。 该函数将会阻塞直至 exit-status 被接收或 IO 出现错误。

func (*Session) SendSignal 

func (s *Session) SendSignal(sig Signal) error

SendSignal 发送 signal 请求至服务端；是否起作用取决于服务器的实现。

func (*Session) SendWinChange 

func (s *Session) SendWinChange(fd, oldTermHeight, oldTermWidth int) (int, int, error)

SendWinChange 从fd中获取终端大小并与传入参数比较，如果发生变化则向该会话发送一个 window-change 请求。 返回最新检测的窗口宽度与长度

func (*Session) SetEnv 

func (s *Session) SetEnv(name, value string) error

SetEnv 为当前会话设置环境变量；是否起作用取决于服务器的实现。

func (*Session) SetEnvs 

func (s *Session) SetEnvs(envs *map[string]string) error

SetEnvs 为session设置环境变量，遍历 envs 并发送 env 请求；是否起作用取决于服务器的实现。 返回最后一个发生的错误；

func (*Session) Shell 

func (s *Session) Shell() error

Shell 发送一个 shell 请求，并阻塞至 exit-status 消息被接收

type Signal 

type Signal string

Signal ssh 包导出的信号定义 

const (
	SIGABRT Signal = "ABRT"
	SIGALRM Signal = "ALRM"
	SIGFPE  Signal = "FPE"
	SIGHUP  Signal = "HUP"
	SIGILL  Signal = "ILL"
	SIGINT  Signal = "INT"
	SIGKILL Signal = "KILL"
	SIGPIPE Signal = "PIPE"
	SIGQUIT Signal = "QUIT"
	SIGSEGV Signal = "SEGV"
	SIGTERM Signal = "TERM"
	SIGUSR1 Signal = "USR1"
	SIGUSR2 Signal = "USR2"
)

Source Files

View all Source files

Directories

Path Synopsis
cli module
client module

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.