How do you implement simple SSH port forwarding in Go?

Simple SSH Port Forwarding in Go

Port forwarding is a useful technique to establish a tunnel between two hosts, allowing traffic to be securely relayed through an intermediary server. In Go, port forwarding can be achieved using the golang.org/x/crypto/ssh package.

Port Forward with Go

A basic port forward setup involves:

1. Creating a local listener to receive incoming connections.
2. Establishing an SSH connection to a remote server.
3. Initiating a connection to the destination port on the remote server.
4. Relaying data between the local listener and the remote connection.

Code Example

Here's a simple Go code example demonstrating port forwarding from a local port (9000) to a remote port (9999) on a remote server:

<code class="go">package main

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

const (
    localAddrString  = "localhost:9000"
    remoteAddrString = "localhost:9999"
    serverAddrString = "192.168.1.100:22"
    username         = "root"
    password         = "password"
)

func forward(localConn net.Conn, config *ssh.ClientConfig) {
    // Establish SSH connection to remote server
    sshClientConn, err := ssh.Dial("tcp", serverAddrString, config)
    if err != nil {
        log.Fatalf("ssh.Dial failed: %s", err)
    }
    defer sshClientConn.Close()

    // Establish connection to remote destination port
    sshConn, err := sshClientConn.Dial("tcp", remoteAddrString)
    if err != nil {
        log.Fatalf("sshClientConn.Dial failed: %s", err)
    }
    defer sshConn.Close()

    // Relay data between local and remote connections
    go func() {
        if _, err := io.Copy(sshConn, localConn); err != nil {
            log.Fatalf("io.Copy failed: %v", err)
        }
    }()

    go func() {
        if _, err := io.Copy(localConn, sshConn); err != nil {
            log.Fatalf("io.Copy failed: %v", err)
        }
    }()
}

func main() {
    // Configure SSH client
    config := &ssh.ClientConfig{
        User: username,
        Auth: []ssh.AuthMethod{
            ssh.Password(password),
        },
    }

    // Create local listener
    localListener, err := net.Listen("tcp", localAddrString)
    if err != nil {
        log.Fatalf("net.Listen failed: %v", err)
    }

    // Accept incoming connections and forward them
    for {
        localConn, err := localListener.Accept()
        if err != nil {
            log.Fatalf("listener.Accept failed: %v", err)
        }

        go forward(localConn, config)
    }
}</code>

This code starts by creating a local listener on port 9000, then establishes a client connection to the remote SSH server. Next, SSH connections are initiated to the destination port (9999) on the remote server. Finally, data is relayed between the local and remote connections via goroutines.

The above is the detailed content of How do you implement simple SSH port forwarding in Go?. For more information, please follow other related articles on the PHP Chinese website!