使用golang创建REST API以通过SSH隧道发送消息的方法

package main
import (
    "fmt"
    "golang.org/x/crypto/ssh"
    "io"
    "io/ioutil"
    "log"
    "net"
    "strconv"
    "strings"
)
type endpoint struct {
    host string
    port int
    user string
}
func newendpoint(s string) *endpoint {
    endpoint := &endpoint{
        host: s,
    }
    if parts := strings.split(endpoint.host, "@"); len(parts) > 1 {
        endpoint.user = parts[0]
        endpoint.host = parts[1]
    }
    if parts := strings.split(endpoint.host, ":"); len(parts) > 1 {
        endpoint.host = parts[0]
        endpoint.port, _ = strconv.atoi(parts[1])
    }
    return endpoint
}
func (endpoint *endpoint) string() string {
    return fmt.sprintf("%s:%d", endpoint.host, endpoint.port)
}
type sshtunnel struct {
    local  *endpoint
    server *endpoint
    remote *endpoint
    config *ssh.clientconfig
    log    *log.logger
}
func (tunnel *sshtunnel) logf(fmt string, args ...interface{}) {
    if tunnel.log != nil {
        tunnel.log.printf(fmt, args...)
    }
}
func (tunnel *sshtunnel) start() error {
    listener, err := net.listen("tcp", tunnel.local.string())
    if err != nil {
        return err
    }
    defer listener.close()
    tunnel.local.port = listener.addr().(*net.tcpaddr).port
    for {
        conn, err := listener.accept()
        if err != nil {
            return err
        }
        tunnel.logf("accepted connection")
        go tunnel.forward(conn)
    }
}
func (tunnel *sshtunnel) forward(localconn net.conn) {
    serverconn, err := ssh.dial("tcp", tunnel.server.string(), tunnel.config)
    if err != nil {
        tunnel.logf("server dial error: %s", err)
        return
    }
    tunnel.logf("connected to %s (1 of 2)\n", tunnel.server.string())
    remoteconn, err := serverconn.dial("tcp", tunnel.remote.string())
    if err != nil {
        tunnel.logf("remote dial error: %s", err)
        return
    }
    tunnel.logf("connected to %s (2 of 2)\n", tunnel.remote.string())
    copyconn := func(writer, reader net.conn) {
        _, err := io.copy(writer, reader)
        if err != nil {
            tunnel.logf("io.copy error: %s", err)
        }
    }
    go copyconn(localconn, remoteconn)
    go copyconn(remoteconn, localconn)
}
func privatekeyfile(file string) ssh.authmethod {
    buffer, err := ioutil.readfile(file)
    if err != nil {
        return nil
    }
    key, err := ssh.parseprivatekey(buffer)
    if err != nil {
        return nil
    }
    return ssh.publickeys(key)
}
func newsshtunnel(tunnel string, auth ssh.authmethod, destination string) *sshtunnel {
    // a random port will be chosen for us.
    localendpoint := newendpoint("localhost:0")
    server := newendpoint(tunnel)
    if server.port == 0 {
        server.port = 22
    }
    sshtunnel := &sshtunnel{
        config: &ssh.clientconfig{
            user: server.user,
            auth: []ssh.authmethod{auth},
            hostkeycallback: func(hostname string, remote net.addr, key ssh.publickey) error {
                // always accept key.
                return nil
            },
        },
        local:  localendpoint,
        server: server,
        remote: newendpoint(destination),
    }
    return sshtunnel
}

这是一个使用示例：

func main() {
   // Setup the tunnel, but do not yet start it yet.
   tunnel := NewSSHTunnel(
      // User and host of tunnel server, it will default to port 22
      // if not specified.
      "[email protected]",
      // Pick ONE of the following authentication methods:
      PrivateKeyFile("path/to/private/key.pem"), // 1. private key
      ssh.Password("password"),                  // 2. password
      // The destination host and port of the actual server.
      "dqrsdfdssdfx.us-east-1.redshift.amazonaws.com:5439",
   )
   // You can provide a logger for debugging, or remove this line to
   // make it silent.
   tunnel.Log = log.New(os.Stdout, "", log.Ldate | log.Lmicroseconds)
   // Start the server in the background. You will need to wait a
   // small amount of time for it to bind to the localhost port
   // before you can start sending connections.
   go tunnel.Start()
   time.Sleep(100 * time.Millisecond)
   // NewSSHTunnel will bind to a random port so that you can have
   // multiple SSH tunnels available. The port is available through:
   //   tunnel.Local.Port
   
   // You can use any normal Go code to connect to the destination
   // server through localhost. You may need to use 127.0.0.1 for
   // some libraries.
   //
   // Here is an example of connecting to a PostgreSQL server:
   conn := fmt.Sprintf("host=127.0.0.1 port=%d username=foo", tunnel.Local.Port)
   db, err := sql.Open("postgres", conn)
   // ...
}