Golang中使用带密码的Ed25519私钥SSH时出现"PassPhraseMissingError"错误

问题出在Go的x/crypto/ssh包对加密的OpenSSH格式Ed25519私钥支持不完整。当使用ParseRawPrivateKey解析带密码的Ed25519密钥时，会返回PassPhraseMissingError错误，因为该函数没有实现解密逻辑。

以下是解决方案的示例代码：

package main

import (
    "bytes"
    "encoding/pem"
    "errors"
    "fmt"
    "io/ioutil"
    
    "golang.org/x/crypto/ssh"
    "golang.org/x/crypto/ssh/agent"
)

// 自定义函数处理加密的OpenSSH私钥
func parseEncryptedPrivateKey(data []byte, passphrase []byte) (interface{}, error) {
    // 尝试解析为PEM格式
    block, _ := pem.Decode(data)
    if block != nil {
        // 如果是加密的PEM格式
        if x509.IsEncryptedPEMBlock(block) {
            decrypted, err := x509.DecryptPEMBlock(block, passphrase)
            if err != nil {
                return nil, err
            }
            return ssh.ParseRawPrivateKey(decrypted)
        }
        return ssh.ParseRawPrivateKey(data)
    }
    
    // 处理OpenSSH格式的加密密钥
    if bytes.Contains(data, []byte("OPENSSH PRIVATE KEY")) {
        // 使用ssh-agent兼容的方式解密
        key, err := ssh.ParseRawPrivateKeyWithPassphrase(data, passphrase)
        if err != nil {
            return nil, fmt.Errorf("failed to parse encrypted openssh key: %w", err)
        }
        return key, nil
    }
    
    return nil, errors.New("unsupported key format")
}

// 替代方案：使用ssh-agent
func loadEncryptedKeyWithAgent(keyPath string, passphrase []byte) (ssh.Signer, error) {
    keyData, err := ioutil.ReadFile(keyPath)
    if err != nil {
        return nil, err
    }
    
    // 创建内存中的ssh-agent
    ag := agent.NewKeyring()
    
    // 使用agent.Add方法添加加密的密钥
    addedKey := agent.AddedKey{
        PrivateKey:   keyData,
        Comment:      "",
        LifetimeSecs: 0,
    }
    
    // 对于加密的密钥，需要设置解密函数
    signer, err := ssh.ParsePrivateKeyWithPassphrase(keyData, passphrase)
    if err != nil {
        return nil, err
    }
    
    // 添加到agent
    if err := ag.Add(agent.AddedKey{
        PrivateKey:   signer,
        Comment:      "",
        LifetimeSecs: 0,
    }); err != nil {
        return nil, err
    }
    
    return signer, nil
}

// 主函数示例
func main() {
    keyPath := "path/to/ed25519_key"
    passphrase := []byte("your_password")
    
    // 方法1：使用自定义解析函数
    keyData, err := ioutil.ReadFile(keyPath)
    if err != nil {
        panic(err)
    }
    
    privateKey, err := parseEncryptedPrivateKey(keyData, passphrase)
    if err != nil {
        // 方法2：使用ssh-agent方式
        signer, err := loadEncryptedKeyWithAgent(keyPath, passphrase)
        if err != nil {
            panic(err)
        }
        
        // 使用signer进行SSH认证
        config := &ssh.ClientConfig{
            User: "git",
            Auth: []ssh.AuthMethod{
                ssh.PublicKeys(signer),
            },
            HostKeyCallback: ssh.InsecureIgnoreHostKey(),
        }
        
        // 连接SSH服务器
        client, err := ssh.Dial("tcp", "github.com:22", config)
        if err != nil {
            panic(err)
        }
        defer client.Close()
        
        fmt.Println("SSH connection established")
    }
}

对于go-git库，可以使用以下方式：

import (
    "gopkg.in/src-d/go-git.v4"
    "gopkg.in/src-d/go-git.v4/plumbing/transport/ssh"
)

func cloneWithEncryptedEd25519() error {
    publicKeys, err := ssh.NewPublicKeysFromFile("git", "path/to/ed25519_key", "password")
    if err != nil {
        // 如果上述方法失败，使用自定义的AuthMethod
        auth, err := createCustomAuth("path/to/ed25519_key", "password")
        if err != nil {
            return err
        }
        
        _, err = git.PlainClone("/path/to/repo", false, &git.CloneOptions{
            URL:      "git@github.com:user/repo.git",
            Auth:     auth,
            Progress: os.Stdout,
        })
        return err
    }
    
    _, err = git.PlainClone("/path/to/repo", false, &git.CloneOptions{
        URL:      "git@github.com:user/repo.git",
        Auth:     publicKeys,
        Progress: os.Stdout,
    })
    return err
}

func createCustomAuth(keyPath, password string) (ssh.AuthMethod, error) {
    keyData, err := ioutil.ReadFile(keyPath)
    if err != nil {
        return nil, err
    }
    
    signer, err := ssh.ParsePrivateKeyWithPassphrase(keyData, []byte(password))
    if err != nil {
        return nil, err
    }
    
    return ssh.PublicKeys(signer), nil
}

注意：这个问题在Go 1.16中确实存在，因为x/crypto/ssh包对加密的OpenSSH格式Ed25519密钥支持有限。建议升级到更新的Go版本，或者使用上述的变通方案。