golang 通过ssh代理连接mysql的操作

我就废话不多说了，大家还是直接看代码吧~

package main
import (
    "bytes"
    "context"
    "database/sql"
    "errors"
    "fmt"
    "github.com/go-sql-driver/mysql"
    "golang.org/x/crypto/ssh"
    "io"
    "io/ioutil"
    "net"
    "os"
)
type ViaSSHDialer struct {
    client *ssh.Client
    _ *context.Context
}
 
func (self *ViaSSHDialer) Dial(context context.Context,addr string) (net.Conn, error) {
    return self.client.Dial("tcp", addr)
}
type remoteScriptType byte
type remoteShellType byte
 
const (
    cmdLine remoteScriptType = iota
    rawScript
    scriptFile 
    interactiveShell remoteShellType = iota
    nonInteractiveShell
)
 
type Client struct {
    client *ssh.Client
}
func main() {
    client, err := DialWithPasswd("ip:port", "user", "password")
    if err != nil {
        panic(err)
    }
    out, err := client.Cmd("ls -l").Output()
    if err != nil {
        panic(err)
    }
    fmt.Println(string(out))
    // Now we register the ViaSSHDialer with the ssh connection as a parameter
    mysql.RegisterDialContext("mysql+tcp", (&ViaSSHDialer{client.client,nil}).Dial)
    //mysql.RegisterDial("mysql+tcp", (&ViaSSHDialer{client.client}).Dial)
    if db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@mysql+tcp(%s)/%s","Aiqitest", "uf6amk146d2aoemi7", "139.196.174.234:3306", "Aiqitest"));
    err == nil {
        fmt.Printf("Successfully connected to the db\n")
        if rows, err := db.Query("SELECT id, name FROM table ORDER BY id"); err == nil {
            for rows.Next() {
                var id int64
                var name string
                rows.Scan(&id, &name)
                fmt.Printf("ID: %d Name: %s\n", id, name)
            }
            rows.Close()
        } else {
            fmt.Printf("Failure: %s", err.Error())
        }
 
        db.Close()
}
    }
 
// DialWithPasswd starts a client connection to the given SSH server with passwd authmethod.
func DialWithPasswd(addr, user, passwd string) (*Client, error) {
    config := &ssh.ClientConfig{
        User: user,
        Auth: []ssh.AuthMethod{
            ssh.Password(passwd),
        },
        HostKeyCallback: ssh.HostKeyCallback(func(hostname string, remote net.Addr, key ssh.PublicKey) error { return nil }),
    }
 
    return Dial("tcp", addr, config)
}
 
// DialWithKey starts a client connection to the given SSH server with key authmethod.
func DialWithKey(addr, user, keyfile string) (*Client, error) {
    key, err := ioutil.ReadFile(keyfile)
    if err != nil {
        return nil, err
    }
 
    signer, err := ssh.ParsePrivateKey(key)
    if err != nil {
        return nil, err
    }
 
    config := &ssh.ClientConfig{
        User: user,
        Auth: []ssh.AuthMethod{
            ssh.PublicKeys(signer),
        },
        HostKeyCallback: ssh.HostKeyCallback(func(hostname string, remote net.Addr, key ssh.PublicKey) error { return nil }),
    }
 
    return Dial("tcp", addr, config)
}
 
// DialWithKeyWithPassphrase same as DialWithKey but with a passphrase to decrypt the private key
func DialWithKeyWithPassphrase(addr, user, keyfile string, passphrase string) (*Client, error) {
    key, err := ioutil.ReadFile(keyfile)
    if err != nil {
        return nil, err
    }
 
    signer, err := ssh.ParsePrivateKeyWithPassphrase(key, []byte(passphrase))
    if err != nil {
        return nil, err
    }
 
    config := &ssh.ClientConfig{
        User: user,
        Auth: []ssh.AuthMethod{
            ssh.PublicKeys(signer),
        },
        HostKeyCallback: ssh.HostKeyCallback(func(hostname string, remote net.Addr, key ssh.PublicKey) error { return nil }),
    } 
    return Dial("tcp", addr, config)
}
 
// Dial starts a client connection to the given SSH server.
// This is wrap the ssh.Dial
func Dial(network, addr string, config *ssh.ClientConfig) (*Client, error) {
    client, err := ssh.Dial(network, addr, config)
    if err != nil {
        return nil, err
    }
    return &Client{
        client: client,
    }, nil
}
 
func (c *Client) Close() error {
    return c.client.Close()
}
 
// Cmd create a command on client
func (c *Client) Cmd(cmd string) *remoteScript {
    return &remoteScript{
        _type: cmdLine,
        client: c.client,
        script: bytes.NewBufferString(cmd + "\n"),
    }
}
 
// Script
func (c *Client) Script(script string) *remoteScript {
    return &remoteScript{
        _type: rawScript,
        client: c.client,
        script: bytes.NewBufferString(script + "\n"),
    }
}
 
// ScriptFile
func (c *Client) ScriptFile(fname string) *remoteScript {
    return &remoteScript{
        _type:   scriptFile,
        client:   c.client,
        scriptFile: fname,
    }
}
 
type remoteScript struct {
    client   *ssh.Client
    _type   remoteScriptType
    script   *bytes.Buffer
    scriptFile string
    err    error
 
    stdout io.Writer
    stderr io.Writer
}
 
// Run
func (rs *remoteScript) Run() error {
    if rs.err != nil {
        fmt.Println(rs.err)
        return rs.err
    }
 
    if rs._type == cmdLine {
        return rs.runCmds()
    } else if rs._type == rawScript {
        return rs.runScript()
    } else if rs._type == scriptFile {
        return rs.runScriptFile()
    } else {
        return errors.New("Not supported remoteScript type")
    }
}
 
func (rs *remoteScript) Output() ([]byte, error) {
    if rs.stdout != nil {
        return nil, errors.New("Stdout already set")
    }
    var out bytes.Buffer
    rs.stdout = &out
    err := rs.Run()
    return out.Bytes(), err
}
 
func (rs *remoteScript) SmartOutput() ([]byte, error) {
    if rs.stdout != nil {
        return nil, errors.New("Stdout already set")
    }
    if rs.stderr != nil {
        return nil, errors.New("Stderr already set")
    }
 
    var (
        stdout bytes.Buffer
        stderr bytes.Buffer
    )
    rs.stdout = &stdout
    rs.stderr = &stderr
    err := rs.Run()
    if err != nil {
        return stderr.Bytes(), err
    }
    return stdout.Bytes(), err
}
 
func (rs *remoteScript) Cmd(cmd string) *remoteScript {
    _, err := rs.script.WriteString(cmd + "\n")
    if err != nil {
        rs.err = err
    }
    return rs
}
 
func (rs *remoteScript) SetStdio(stdout, stderr io.Writer) *remoteScript {
    rs.stdout = stdout
    rs.stderr = stderr
    return rs
}
 
func (rs *remoteScript) runCmd(cmd string) error {
    session, err := rs.client.NewSession()
    if err != nil {
        return err
    }
    defer session.Close()
 
    session.Stdout = rs.stdout
    session.Stderr = rs.stderr
 
    if err := session.Run(cmd); err != nil {
        return err
    }
    return nil
}
 
func (rs *remoteScript) runCmds() error {
    for {
        statment, err := rs.script.ReadString('\n')
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
 
        if err := rs.runCmd(statment); err != nil {
            return err
        }
    }
 
    return nil
}
 
func (rs *remoteScript) runScript() error {
    session, err := rs.client.NewSession()
    if err != nil {
        return err
    }
 
    session.Stdin = rs.script
    session.Stdout = rs.stdout
    session.Stderr = rs.stderr 
    if err := session.Shell(); err != nil {
        return err
    }
    if err := session.Wait(); err != nil {
        return err
    }
 
    return nil
}
 
func (rs *remoteScript) runScriptFile() error {
    var buffer bytes.Buffer
    file, err := os.Open(rs.scriptFile)
    if err != nil {
        return err
    }
    _, err = io.Copy(&buffer, file)
    if err != nil {
        return err
    }
 
    rs.script = &buffer
    return rs.runScript()
}
 
type remoteShell struct {
    client     *ssh.Client
    requestPty   bool
    terminalConfig *TerminalConfig
 
    stdin io.Reader
    stdout io.Writer
    stderr io.Writer
}
 
type TerminalConfig struct {
    Term  string
    Hight int
    Weight int
    Modes ssh.TerminalModes
}
 
// Terminal create a interactive shell on client.
func (c *Client) Terminal(config *TerminalConfig) *remoteShell {
    return &remoteShell{
        client:     c.client,
        terminalConfig: config,
        requestPty:   true,
    }
}
 
// Shell create a noninteractive shell on client.
func (c *Client) Shell() *remoteShell {
    return &remoteShell{
        client:   c.client,
        requestPty: false,
    }
}
 
func (rs *remoteShell) SetStdio(stdin io.Reader, stdout, stderr io.Writer) *remoteShell {
    rs.stdin = stdin
    rs.stdout = stdout
    rs.stderr = stderr
    return rs
}
 
// Start start a remote shell on client
func (rs *remoteShell) Start() error {
    session, err := rs.client.NewSession()
    if err != nil {
        return err
    }
    defer session.Close()
 
    if rs.stdin == nil {
        session.Stdin = os.Stdin
    } else {
        session.Stdin = rs.stdin
    }
    if rs.stdout == nil {
        session.Stdout = os.Stdout
    } else {
        session.Stdout = rs.stdout
    }
    if rs.stderr == nil {
        session.Stderr = os.Stderr
    } else {
        session.Stderr = rs.stderr
    }
 
    if rs.requestPty {
        tc := rs.terminalConfig
        if tc == nil {
            tc = &TerminalConfig{
                Term:  "xterm",
                Hight: 40,
                Weight: 80,
            }
        }
        if err := session.RequestPty(tc.Term, tc.Hight, tc.Weight, tc.Modes); err != nil {
            return err
        }
    }
 
    if err := session.Shell(); err != nil {
        return err
    }
 
    if err := session.Wait(); err != nil {
        return err
    } 
    return nil
}

补充：用golang写socks5代理服务器2-ssh远程代理

上次用golang来实现本地socks5代理，然而使用代理当然是为了和谐上网，所以这次来介绍用ssh来实现远程代理,用到官方ssh包

golang.org/x/crypto/ssh

用golang连接ssh并不难

读取密钥，设置配置，连接服务器就ok了（不建议用用户名+密码方式连接ssh)

 b, err := ioutil.ReadFile("/home/myml/.ssh/id_rsa")
 if err != nil {
 log.Println(err)
 return
 }
 pKey, err := ssh.ParsePrivateKey(b)
 if err != nil {
 log.Println(err)
 return
 }
 config := ssh.ClientConfig{
 User: "userName",
 Auth: []ssh.AuthMethod{
  ssh.PublicKeys(pKey),
 },
 }
 client, err = ssh.Dial("tcp", "Host:22", &config)
 if err != nil {
 log.Println(err)
 return
 }
 log.Println("连接服务器成功")
 defer client.Close()

这样你就得到了一个client，它有个Dial()函数用来创建socket连接，这个是在服务器上创建的，也就可以突破网络限制了，加上上次的sock5代理，把net.Dial改为client.Dial，就能让服务器来代理访问了

 server, err := client.Dial("tcp", addr)
 if err != nil {
 log.Println(err)
 return
 }
 conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
 go io.Copy(server, conn)
 io.Copy(conn, server)

下面是能成功运行并进行远程代理的代码(在Chrome和proxychains测试），ssh服务器和配置信息要修改为自己的

// socks5ProxyProxy project main.go
package main 
import (
 "bytes"
 "encoding/binary"
 "fmt"
 "io"
 "io/ioutil"
 "log"
 "net" 
 "golang.org/x/crypto/ssh"
)
 
func socks5Proxy(conn net.Conn) {
 defer conn.Close()
 
 var b [1024]byte 
 n, err := conn.Read(b[:])
 if err != nil {
 log.Println(err)
 return
 }
 log.Printf("% x", b[:n]) 
 conn.Write([]byte{0x05, 0x00})
 
 n, err = conn.Read(b[:])
 if err != nil {
 log.Println(err)
 return
 }
 log.Printf("% x", b[:n])
 
 var addr string
 switch b[3] {
 case 0x01:
 sip := sockIP{}
 if err := binary.Read(bytes.NewReader(b[4:n]), binary.BigEndian, &sip); err != nil {
  log.Println("请求解析错误")
  return
 }
 addr = sip.toAddr()
 case 0x03:
 host := string(b[5 : n-2])
 var port uint16
 err = binary.Read(bytes.NewReader(b[n-2:n]), binary.BigEndian, &port)
 if err != nil {
  log.Println(err)
  return
 }
 addr = fmt.Sprintf("%s:%d", host, port)
 }
 
 server, err := client.Dial("tcp", addr)
 if err != nil {
 log.Println(err)
 return
 }
 conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
 go io.Copy(server, conn)
 io.Copy(conn, server)
}
 
type sockIP struct {
 A, B, C, D byte
 PORT    uint16
}
 
func (ip sockIP) toAddr() string {
 return fmt.Sprintf("%d.%d.%d.%d:%d", ip.A, ip.B, ip.C, ip.D, ip.PORT)
}
 
func socks5ProxyStart() {
 log.SetFlags(log.Ltime | log.Lshortfile)
 
 server, err := net.Listen("tcp", ":8080")
 if err != nil {
 log.Panic(err)
 }
 defer server.Close()
 log.Println("开始接受连接")
 for {
 client, err := server.Accept()
 if err != nil {
  log.Println(err)
  return
 }
 log.Println("一个新连接")
 go socks5Proxy(client)
 }
}
 
var client *ssh.Client 
func main() {
 b, err := ioutil.ReadFile("/home/myml/.ssh/id_rsa")
 if err != nil {
 log.Println(err)
 return
 }
 pKey, err := ssh.ParsePrivateKey(b)
 if err != nil {
 log.Println(err)
 return
 }
 config := ssh.ClientConfig{
 User: "user",
 Auth: []ssh.AuthMethod{
  ssh.PublicKeys(pKey),
 },
 }
 client, err = ssh.Dial("tcp", "host:22", &config)
 if err != nil {
 log.Println(err)
 return
 }
 log.Println("连接服务器成功")
 defer client.Close()
 client.Dial()
 socks5ProxyStart()
 return
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持球儿工具。如有错误或未考虑完全的地方，望不吝赐教。

mysql sql ssh