Wie authentifiziere ich mich bei SSH mit einem PEM/Schlüssel in Go?

Authentifizierung bei SSH mit einem PEM/Schlüssel in Go

Das Herstellen einer Verbindung zu einem Remote-SSH-Server mithilfe eines privaten Schlüssels kann eine bequeme Möglichkeit sein Automatisieren Sie Aufgaben und verwalten Sie Ressourcen. Die Programmiersprache Go bietet das Paket ssh an, das den Aufbau von SSH-Verbindungen unterstützt. Die Dokumentation kann jedoch etwas unklar sein, wie man sich mit einem privaten Schlüssel authentifiziert.

Um über SSH mit einem PEM-Schlüssel eine Verbindung zu einem Server herzustellen, können Sie die folgenden Schritte ausführen:

1. Besorgen Sie sich einen Signer:Sie müssen einen ssh.Signer von Ihrem privaten Schlüssel erhalten. Dies kann mit der Funktion ssh.ParsePrivateKey oder der Funktion ssh.NewSignerFromKey für bestimmte Schlüsseltypen (z. B. rsa, dsa, ecdsa) erfolgen.
2. Erstellen Sie eine AuthMethod: Konvertieren Sie das Signer-Objekt in eine ssh.AuthMethod mithilfe der Funktion ssh.PublicKeys umwandeln. Dadurch wird der Unterzeichner umhüllt und ermöglicht die Verwendung für die Authentifizierung während der SSH-Verbindung.
3. ClientConfig konfigurieren: Richten Sie ein ssh.ClientConfig-Objekt ein, das Ihre Authentifizierungsmethode, Ihren Benutzernamen und alles andere enthält notwendige Konfigurationsparameter.
4. Wählen Sie die Verbindung: Verwenden Sie die ssh.Dial-Funktion, um mithilfe Ihrer ClientConfig eine Verbindung zum Remote-Server herzustellen.
5. Erstellen Sie eine Sitzung : Sobald die Verbindung hergestellt ist, erstellen Sie eine ssh.Session, um Befehle auf dem Remote-Server auszuführen.

Beispiel:

<code class="go">package main

import (
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "log"
    "net"
    "os"

    "golang.org/x/crypto/ssh"
)

func main() {
    // Parse the private key
    key, err := ioutil.ReadFile("mykey.pem")
    if err != nil {
        log.Fatal(err)
    }

    // Get the signer
    signer, err := ssh.ParsePrivateKey(key)
    if err != nil {
        log.Fatal(err)
    }

    // Switch to using an agent if SSH_AUTH_SOCK is set
    if authSock := os.Getenv("SSH_AUTH_SOCK"); authSock != "" {
        sock, err := net.Dial("unix", authSock)
        if err != nil {
            log.Fatalf("Failed to connect to agent: %v", err)
        }
        _ = sock
        // TODO(harsh)
        // Implement working with agent.
    }

    // Create the AuthMethod
    authMethods := []ssh.AuthMethod{ssh.PublicKeys(signer)}

    // Set up the ClientConfig
    clientConfig := &ssh.ClientConfig{
        User:            "username",
        Auth:            authMethods,
        HostKeyCallback: ssh.InsecureIgnoreHostKey(),
    }

    // Dial the connection
    client, err := ssh.Dial("tcp", "aws-hostname:22", clientConfig)
    if err != nil {
        log.Fatal(err)
    }

    // Create a session
    session, err := client.NewSession()
    if err != nil {
        log.Fatal(err)
    }

    // Execute a command
    output, err := session.Output("whoami")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Output:", string(output))

    // Close the session and client
    _ = session.Close()
    _ = client.Close()
}</code>

Von Wenn Sie diese Schritte befolgen, können Sie mithilfe eines privaten Schlüssels eine sichere SSH-Verbindung herstellen und mithilfe des SSH-Pakets der Go-Standardbibliothek Befehle auf dem Remote-Server ausführen.

Das obige ist der detaillierte Inhalt vonWie authentifiziere ich mich bei SSH mit einem PEM/Schlüssel in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!