Comment s'authentifier sur SSH avec un PEM/Key in Go ?

S'authentifier sur SSH avec un pem/Key in Go

La connexion à un serveur SSH distant à l'aide d'une clé privée peut être un moyen pratique de automatisez les tâches et gérez les ressources. Le langage de programmation Go propose le package ssh, qui prend en charge l'établissement de connexions SSH. Cependant, la documentation peut être quelque peu floue sur la façon de s'authentifier avec une clé privée.

Pour vous connecter à un serveur via SSH avec une clé pem, vous pouvez suivre ces étapes :

1. Obtenir un signataire : Vous devez obtenir un ssh.Signer à partir de votre clé privée. Cela peut être fait en utilisant la fonction ssh.ParsePrivateKey ou la fonction ssh.NewSignerFromKey pour des types de clés spécifiques (par exemple, rsa, dsa, ecdsa).
2. Créez une AuthMethod : Convertissez l'objet Signer dans un ssh.AuthMethod à l'aide de la fonction ssh.PublicKeys. Cela enveloppe le signataire et lui permet d'être utilisé pour l'authentification lors de la connexion SSH.
3. Configurez ClientConfig : Configurez un objet ssh.ClientConfig qui inclut votre méthode d'authentification, votre nom d'utilisateur et tout autre paramètres de configuration nécessaires.
4. Composez la connexion : Utilisez la fonction ssh.Dial pour établir une connexion au serveur distant à l'aide de votre ClientConfig.
5. Créez une session :Une fois la connexion établie, créez une ssh.Session pour exécuter des commandes sur le serveur distant.

Exemple :

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

Par en suivant ces étapes, vous pouvez établir une connexion SSH sécurisée à l'aide d'une clé privée et exécuter des commandes sur le serveur distant à l'aide du package ssh de la bibliothèque standard Go.

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!