• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    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
    }
     

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

    您可能感兴趣的文章:
    • golang中连接mysql数据库
    • Golang操作MySql数据库的完整步骤记录
    • golang实现mysql数据库事务的提交与回滚
    上一篇:浅谈golang结构体偷懒初始化
    下一篇:让goland支持proto文件类型的实现
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

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