154 lines
4.3 KiB
Go
154 lines
4.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
|
|
"golang.org/x/crypto/ssh"
|
|
)
|
|
|
|
const (
|
|
dialTimeout = 10 * time.Second
|
|
commandTimeout = 30 * time.Second
|
|
maxOutput = 1 << 20
|
|
)
|
|
|
|
// run executes command on target and returns its stdout. A command that
|
|
// prints something and then exits non-zero (du meeting a directory it can't
|
|
// read) still returns what it printed.
|
|
func (h *host) run(ctx context.Context, target Target, command string) ([]byte, error) {
|
|
r := h.execute(ctx, target, command)
|
|
if len(r.out) > 0 {
|
|
return r.out, nil
|
|
}
|
|
return nil, r.err
|
|
}
|
|
|
|
// execResult is what a command did. started is false when it never reached
|
|
// the remote shell (no connection, handshake or session), so nothing ran. A
|
|
// started command that did not exit (the session dropped, the deadline
|
|
// passed) may have done part or all of its work.
|
|
type execResult struct {
|
|
out []byte
|
|
started bool
|
|
exited bool
|
|
status int
|
|
err error
|
|
}
|
|
|
|
func (h *host) execute(ctx context.Context, target Target, command string) execResult {
|
|
ctx, cancel := context.WithTimeout(ctx, commandTimeout)
|
|
defer cancel()
|
|
conn, err := dial(ctx, target.Address)
|
|
if err != nil {
|
|
return execResult{err: fmt.Errorf("reach %s: %w", target.Name, err)}
|
|
}
|
|
stop := context.AfterFunc(ctx, func() { _ = conn.Close() })
|
|
defer stop()
|
|
cc, chans, reqs, err := ssh.NewClientConn(conn, target.Address, h.clientConfig(target))
|
|
if err != nil {
|
|
_ = conn.Close()
|
|
return execResult{err: fmt.Errorf("ssh to %s: %w", target.Name, err)}
|
|
}
|
|
client := ssh.NewClient(cc, chans, reqs)
|
|
defer func() { _ = client.Close() }()
|
|
session, err := client.NewSession()
|
|
if err != nil {
|
|
return execResult{err: fmt.Errorf("ssh session on %s: %w", target.Name, err)}
|
|
}
|
|
defer func() { _ = session.Close() }()
|
|
var out limited
|
|
session.Stdout = &out
|
|
err = session.Run(command)
|
|
res := execResult{out: out.Bytes(), started: true, exited: err == nil}
|
|
if err != nil {
|
|
res.err = fmt.Errorf("on %s: %w", target.Name, err)
|
|
var exit *ssh.ExitError
|
|
if errors.As(err, &exit) {
|
|
res.exited, res.status = true, exit.ExitStatus()
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
// clientConfig pins the target's host key. It asks only for that key's
|
|
// algorithm: a host holding several keys would otherwise present its
|
|
// preferred one, and a correct pin would read as a mismatch.
|
|
func (h *host) clientConfig(target Target) *ssh.ClientConfig {
|
|
algorithms := []string{target.key.Type()}
|
|
if target.key.Type() == ssh.KeyAlgoRSA {
|
|
algorithms = []string{ssh.KeyAlgoRSASHA512, ssh.KeyAlgoRSASHA256}
|
|
}
|
|
return &ssh.ClientConfig{
|
|
User: h.username,
|
|
Auth: []ssh.AuthMethod{ssh.PublicKeys(h.signer)},
|
|
HostKeyCallback: ssh.FixedHostKey(target.key),
|
|
HostKeyAlgorithms: algorithms,
|
|
Timeout: dialTimeout,
|
|
}
|
|
}
|
|
|
|
// limited keeps the first maxOutput bytes and drops the rest.
|
|
type limited struct{ bytes.Buffer }
|
|
|
|
func (l *limited) Write(p []byte) (int, error) {
|
|
if room := maxOutput - l.Len(); room > 0 {
|
|
l.Buffer.Write(p[:min(len(p), room)])
|
|
}
|
|
return len(p), nil
|
|
}
|
|
|
|
// dial reaches addr directly, or through the egress tunnel's CONNECT proxy
|
|
// when the connector runs confined.
|
|
func dial(ctx context.Context, addr string) (net.Conn, error) {
|
|
d := net.Dialer{Timeout: dialTimeout}
|
|
proxy := os.Getenv("HTTPS_PROXY")
|
|
if proxy == "" {
|
|
return d.DialContext(ctx, "tcp", addr)
|
|
}
|
|
u, err := url.Parse(proxy)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proxy: %w", err)
|
|
}
|
|
conn, err := d.DialContext(ctx, "tcp", u.Host)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req := &http.Request{Method: http.MethodConnect, URL: &url.URL{Opaque: addr}, Host: addr, Header: http.Header{}}
|
|
if err := req.Write(conn); err != nil {
|
|
_ = conn.Close()
|
|
return nil, err
|
|
}
|
|
br := bufio.NewReader(conn)
|
|
resp, err := http.ReadResponse(br, req)
|
|
if err != nil {
|
|
_ = conn.Close()
|
|
return nil, err
|
|
}
|
|
_ = resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
_ = conn.Close()
|
|
return nil, fmt.Errorf("egress refused %s: %s", addr, resp.Status)
|
|
}
|
|
// The SSH server speaks first, so its banner may already be buffered.
|
|
return &bufferedConn{Conn: conn, r: br}, nil
|
|
}
|
|
|
|
type bufferedConn struct {
|
|
net.Conn
|
|
r io.Reader
|
|
}
|
|
|
|
func (c *bufferedConn) Read(p []byte) (int, error) { return c.r.Read(p) }
|
|
|
|
var errNoCredential = errors.New("the ssh credential slot needs a username and a private_key")
|