Comment implémenter une redirection de port SSH simple dans Go ?

Redirection de port SSH simple dans Go

La redirection de port est une technique utile pour établir un tunnel entre deux hôtes, permettant de relayer le trafic en toute sécurité via un serveur intermédiaire. Dans Go, la redirection de port peut être réalisée à l'aide du package golang.org/x/crypto/ssh.

Redirection de port avec Go

Une configuration de base de redirection de port implique :

1. Création d'un écouteur local pour recevoir les connexions entrantes.
2. Établissement d'une connexion SSH à une télécommande serveur.
3. Initiation d'une connexion au port de destination sur le serveur distant.
4. Relais des données entre l'écouteur local et la connexion distante.

Exemple de code

Voici un exemple de code Go simple illustrant la redirection de port d'un port local (9000) vers un port distant (9999) sur un serveur distant :

<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>

Ce code commence par créer un écouteur local sur le port 9000, puis établit une connexion client au serveur SSH distant. Ensuite, les connexions SSH sont initiées vers le port de destination (9999) sur le serveur distant. Enfin, les données sont relayées entre les connexions locales et distantes via des goroutines.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!