Wie implementiert man eine einfache SSH-Portweiterleitung in Go?

Einfache SSH-Portweiterleitung in Go

Portweiterleitung ist eine nützliche Technik zum Aufbau eines Tunnels zwischen zwei Hosts, sodass der Datenverkehr sicher über einen Zwischenserver weitergeleitet werden kann. In Go kann die Portweiterleitung mithilfe des Pakets golang.org/x/crypto/ssh erreicht werden.

Portweiterleitung mit Go

Eine grundlegende Einrichtung der Portweiterleitung umfasst:

1. Erstellen eines lokalen Listeners zum Empfang eingehender Verbindungen.
2. Herstellen einer SSH-Verbindung zu einem Remote-Server.
3. Initiieren einer Verbindung zum Zielport auf dem Remote-Server.
4. Weiterleitung von Daten zwischen dem lokalen Listener und der Remote-Verbindung.

Codebeispiel

Hier ist ein einfaches Go-Codebeispiel, das die Portweiterleitung von einem lokalen Port (9000) zu einem Remote-Port demonstriert ( 9999) auf einem 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>

Dieser Code erstellt zunächst einen lokalen Listener auf Port 9000 und stellt dann eine Client-Verbindung zum Remote-SSH-Server her. Als nächstes werden SSH-Verbindungen zum Zielport (9999) auf dem Remote-Server initiiert. Schließlich werden die Daten über Goroutinen zwischen den lokalen und Remote-Verbindungen weitergeleitet.

Das obige ist der detaillierte Inhalt vonWie implementiert man eine einfache SSH-Portweiterleitung in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!