Golang程序化SSH交互：输入、输出与命令执行

package main

import (
    "log"
    "os/exec"
    "time"
)

func main() {
    cmd := exec.Command("ssh", "youruser@yourserver.com")

    // 设置标准输出和标准错误，以便观察ssh命令的输出
    // cmd.Stdout = os.Stdout
    // cmd.Stderr = os.Stderr

    stdin, err := cmd.StdinPipe()
    if err != nil {
        log.Fatalf("无法获取StdinPipe: %v", err)
    }
    defer stdin.Close()

    // 启动命令
    if err := cmd.Start(); err != nil {
        log.Fatalf("无法启动SSH命令: %v", err)
    }

    // 尝试写入密码
    // 注意：这种方式通常对交互式SSH密码认证无效
    time.Sleep(1 * time.Second) // 模拟等待提示符出现
    _, err = stdin.Write([]byte("yourpassword\n"))
    if err != nil {
        log.Printf("写入密码失败: %v", err)
    }

    // 等待命令完成
    if err := cmd.Wait(); err != nil {
        log.Printf("SSH命令执行失败: %v", err)
    }
    log.Println("SSH命令执行完毕")
}

import (
    "bytes"
    "fmt"
    "log"

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

config := &ssh.ClientConfig{
    User: "youruser", // 替换为你的SSH用户名
    Auth: []ssh.AuthMethod{
        ssh.Password("yourpassword"), // 替换为你的SSH密码
    },
    // InsecureSkipHostKeyVerification 是为了简化示例，
    // 生产环境中应验证服务器主机密钥以防止中间人攻击。
    // 例如，可以使用 ssh.FixedHostKey(hostKey) 或 ssh.KnownHosts(knownHostsPath)
    HostKeyCallback: ssh.InsecureSkipHostKeyVerification, 
    // 或者，更安全的做法是：
    // HostKeyCallback: ssh.FixedHostKey(hostKey), // 预先知道服务器公钥
    // HostKeyCallback: ssh.KnownHosts(os.Getenv("HOME") + "/.ssh/known_hosts"), // 从known_hosts文件加载
}

client, err := ssh.Dial("tcp", "yourserver.com:22", config) // 替换为你的服务器地址和端口
if err != nil {
    log.Fatalf("无法建立SSH连接: %v", err)
}
defer client.Close() // 确保连接在函数结束时关闭

session, err := client.NewSession()
if err != nil {
    log.Fatalf("无法创建SSH会话: %v", err)
}
defer session.Close() // 确保会话在函数结束时关闭

var stdoutBuf bytes.Buffer
session.Stdout = &stdoutBuf // 将标准输出重定向到缓冲区
session.Stderr = &stdoutBuf // 将标准错误也重定向到同一个缓冲区（可选，也可分开处理）

command := "/usr/bin/whoami" // 你想执行的远程命令
if err := session.Run(command); err != nil {
    log.Fatalf("执行远程命令失败: %v", err)
}

fmt.Printf("远程命令 '%s' 的输出:\n%s\n", command, stdoutBuf.String())

package main

import (
    "bytes"
    "fmt"
    "log"
    "os" // 导入os包以获取HOME环境变量

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

func main() {
    // 1. 配置SSH客户端
    // 替换为你的SSH用户名、密码和服务器地址
    sshUser := "youruser"
    sshPassword := "yourpassword"
    sshServer := "yourserver.com:22"

    config := &ssh.ClientConfig{
        User: sshUser,
        Auth: []ssh.AuthMethod{
            ssh.Password(sshPassword),
        },
        // 生产环境中，强烈建议配置HostKeyCallback以验证服务器主机密钥。
        // 以下两种是更安全的做法：
        // 1. 从 known_hosts 文件加载：
        // HostKeyCallback: ssh.KnownHosts(os.Getenv("HOME") + "/.ssh/known_hosts"),
        // 2. 预设固定主机密钥：
        // HostKeyCallback: ssh.FixedHostKey(hostKey), // hostKey需要提前获取
        //
        // 为简化示例，这里使用不安全的跳过验证，请勿在生产环境使用！
        HostKeyCallback: ssh.InsecureSkipHostKeyVerification,
    }

    // 2. 建立SSH连接
    client, err := ssh.Dial("tcp", sshServer, config)
    if err != nil {
        log.Fatalf("无法建立SSH连接到 %s: %v", sshServer, err)
    }
    defer client.Close() // 确保连接在函数结束时关闭

    log.Printf("成功连接到SSH服务器: %s", sshServer)

    // 3. 创建SSH会话
    session, err := client.NewSession()
    if err != nil {
        log.Fatalf("无法创建SSH会话: %v", err)
    }
    defer session.Close() // 确保会话在函数结束时关闭

    // 4. 配置会话输出并执行远程命令
    var stdoutBuf bytes.Buffer
    session.Stdout = &stdoutBuf // 将远程命令的标准输出重定向到缓冲区
    session.Stderr = &stdoutBuf // 将远程命令的标准错误也重定向到同一个缓冲区

    commandToExecute := "/usr/bin/whoami" // 想要执行的远程命令

    log.Printf("正在执行远程命令: '%s'", commandToExecute)
    if err := session.Run(commandToExecute); err != nil {
        log.Fatalf("执行远程命令 '%s' 失败: %v", commandToExecute, err)
    }

    // 5. 打印命令输出
    fmt.Printf("\n远程命令 '%s' 的输出:\n%s\n", commandToExecute, stdoutBuf.String())

    // 示例：执行另一个命令
    session2, err := client.NewSession()
    if err != nil {
        log.Fatalf("无法创建第二个SSH会话: %v", err)
    }
    defer session2.Close()

    var lsOutput bytes.Buffer
    session2.Stdout = &lsOutput
    session2.Stderr = &lsOutput
    commandToExecute = "ls -l /"
    log.Printf("正在执行远程命令: '%s'", commandToExecute)
    if err := session2.Run(commandToExecute); err != nil {
        log.Fatalf("执行远程命令 '%s' 失败: %v", commandToExecute, err)
    }
    fmt.Printf("\n远程命令 '%s' 的输出:\n%s\n", commandToExecute, lsOutput.String())
}