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
}

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

来源：https://blog.csdn.net/a1658616397/article/details/100890414