Golang实现SSH隧道与嵌入式SSH服务器插件rospo

SSH隧道实现

SSH隧道(端口转发)是一种常用的安全通信方式，下面是一个简单的Golang实现示例：

package main

import (
	"fmt"
	"golang.org/x/crypto/ssh"
	"log"
	"net"
)

func main() {
	// SSH客户端配置
	config := &ssh.ClientConfig{
		User: "username",
		Auth: []ssh.AuthMethod{
			ssh.Password("password"),
		},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
	}

	// 连接到SSH服务器
	client, err := ssh.Dial("tcp", "ssh-server:22", config)
	if err != nil {
		log.Fatal("Failed to dial: ", err)
	}
	defer client.Close()

	// 监听本地端口
	localListener, err := net.Listen("tcp", "localhost:8080")
	if err != nil {
		log.Fatal("Failed to listen locally: ", err)
	}
	defer localListener.Close()

	fmt.Println("SSH tunnel established. Forwarding localhost:8080 to remote:80")

	// 接受本地连接并转发
	for {
		localConn, err := localListener.Accept()
		if err != nil {
			log.Fatal("Failed to accept local connection: ", err)
		}

		go func() {
			// 建立到远程端口的连接
			remoteConn, err := client.Dial("tcp", "localhost:80")
			if err != nil {
				log.Fatal("Failed to dial remote: ", err)
			}

			// 双向转发数据
			go copyConn(localConn, remoteConn)
			go copyConn(remoteConn, localConn)
		}()
	}
}

func copyConn(dst, src net.Conn) {
	defer dst.Close()
	defer src.Close()
	_, err := io.Copy(dst, src)
	if err != nil {
		log.Println("Copy error:", err)
	}
}

嵌入式SSH服务器 - rospo

rospo是一个轻量级的Golang库，用于创建嵌入式SSH服务器和隧道。以下是使用rospo的示例：

安装rospo

go get github.com/ferama/rospo

基本使用示例

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/ferama/rospo/pkg/sshd"
)

func main() {
	// 创建SSH服务器配置
	server := sshd.SshD{
		Key:          "./id_rsa", // SSH密钥路径
		ListenAddr:   ":2222",    // 监听地址
		AuthorizedKeys: "./authorized_keys", // 授权密钥文件
		Shell:       "/bin/bash", // 默认shell
	}

	// 启动SSH服务器
	go func() {
		if err := server.Start(); err != nil {
			log.Fatalf("Failed to start SSH server: %v", err)
		}
	}()

	fmt.Println("SSH server started on port 2222")

	// 保持程序运行
	for {
		time.Sleep(1 * time.Second)
	}
}

使用rospo创建隧道

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/ferama/rospo/pkg/sshd"
	"github.com/ferama/rospo/pkg/tunnel"
)

func main() {
	// 1. 启动SSH服务器
	server := sshd.SshD{
		Key:          "./id_rsa",
		ListenAddr:   ":2222",
		AuthorizedKeys: "./authorized_keys",
	}
	go server.Start()

	// 2. 创建本地到远程的隧道(本地端口转发)
	localTunnel := tunnel.Tunnel{
		Local:  "localhost:8080",  // 本地监听地址
		Remote: "example.com:80",  // 远程目标地址
		Server: "localhost:2222",  // SSH服务器地址
		Key:    "./id_rsa",        // 用于认证的私钥
	}
	go localTunnel.Start()

	// 3. 创建远程到本地的隧道(远程端口转发)
	remoteTunnel := tunnel.Tunnel{
		Remote: "0.0.0.0:9090",    // 远程监听地址
		Local:  "localhost:3000",   // 本地目标地址
		Server: "localhost:2222",   // SSH服务器地址
		Key:    "./id_rsa",         // 用于认证的私钥
		Reverse: true,              // 设置为反向隧道
	}
	go remoteTunnel.Start()

	fmt.Println("Tunnels established:")
	fmt.Println("- Local 8080 -> example.com:80")
	fmt.Println("- Remote 9090 -> localhost:3000")

	// 保持程序运行
	for {
		time.Sleep(1 * time.Second)
	}
}

安全注意事项

1. 在生产环境中，应该使用更安全的认证方式，如公钥认证而非密码
2. 考虑实现主机密钥验证，避免中间人攻击
3. 限制可以访问SSH服务器的IP地址
4. 使用强密码或密钥
5. 定期轮换密钥

rospo提供了更多高级功能，如：

• 动态端口转发(SOCKS代理)
• 连接保持和自动重连
• 多路复用连接
• 连接监控和管理

可以根据项目需求进一步探索rospo的文档和示例。