blob: 044c8198b034065dcdcab5de68bda920073d9437 [file] [edit]
// Copyright 2026 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build go1.27 && !fips140v1.0
package agent
import (
"bytes"
"crypto/mldsa"
"crypto/rand"
"errors"
"strings"
"testing"
"golang.org/x/crypto/ssh"
)
func TestMLDSAKeys(t *testing.T) {
key, err := mldsa.GenerateKey(mldsa.MLDSA65())
if err != nil {
t.Fatal(err)
}
certKey, err := mldsa.GenerateKey(mldsa.MLDSA65())
if err != nil {
t.Fatal(err)
}
certSigner, err := ssh.NewSignerFromKey(certKey)
if err != nil {
t.Fatal(err)
}
cert := &ssh.Certificate{
Key: certSigner.PublicKey(),
CertType: ssh.UserCert,
ValidPrincipals: []string{"testuser"},
ValidBefore: ssh.CertTimeInfinity,
}
if err := cert.SignCert(rand.Reader, testSigners["ed25519"]); err != nil {
t.Fatalf("SignCert: %v", err)
}
keyring := NewKeyring()
for _, k := range []AddedKey{
{PrivateKey: key, Comment: "key"},
{PrivateKey: certKey, Certificate: cert, Comment: "cert"},
} {
if err := keyring.Add(k); err != nil {
t.Fatalf("Keyring.Add: %v", err)
}
}
agent, cleanup := startAgent(t, keyring)
defer cleanup()
for _, k := range []AddedKey{
{PrivateKey: key},
{PrivateKey: certKey, Certificate: cert},
} {
if err := agent.Add(k); err == nil || !strings.Contains(err.Error(), "unsupported key type") {
t.Errorf("Add over the protocol: %v, want an unsupported key type error", err)
}
}
keys, err := agent.List()
if err != nil {
t.Fatalf("List: %v", err)
}
if len(keys) != 2 || keys[0].Type() != ssh.KeyAlgoMLDSA65 || keys[1].Type() != ssh.CertAlgoMLDSA65v01Go {
t.Fatalf("List returned %v", keys)
}
data := []byte("sign me")
for _, k := range keys {
sig, err := agent.Sign(k, data)
if err != nil {
t.Fatalf("Sign(%s): %v", k.Type(), err)
}
pub, err := ssh.ParsePublicKey(k.Marshal())
if err != nil {
t.Fatal(err)
}
if err := pub.Verify(data, sig); err != nil {
t.Errorf("Verify(%s): %v", k.Type(), err)
}
}
// The certificate signer must sign with the underlying algorithm, which
// is what the client asks for during public key authentication.
signers, err := agent.Signers()
if err != nil {
t.Fatalf("Signers: %v", err)
}
as := signers[1].(ssh.AlgorithmSigner)
if _, err := as.SignWithAlgorithm(rand.Reader, data, ssh.KeyAlgoMLDSA65); err != nil {
t.Errorf("SignWithAlgorithm(%s): %v", ssh.KeyAlgoMLDSA65, err)
}
if _, err := as.SignWithAlgorithm(rand.Reader, data, ssh.KeyAlgoMLDSA44); err == nil {
t.Errorf("SignWithAlgorithm(%s) accepted the wrong algorithm", ssh.KeyAlgoMLDSA44)
}
checker := &ssh.CertChecker{IsUserAuthority: func(k ssh.PublicKey) bool {
return bytes.Equal(k.Marshal(), testPublicKeys["ed25519"].Marshal())
}}
for _, tt := range []struct {
name string
signer ssh.Signer
accept func(ssh.ConnMetadata, ssh.PublicKey) (*ssh.Permissions, error)
}{
{"key", signers[0], func(_ ssh.ConnMetadata, k ssh.PublicKey) (*ssh.Permissions, error) {
if !bytes.Equal(k.Marshal(), keys[0].Marshal()) {
return nil, errors.New("pubkey rejected")
}
return nil, nil
}},
{"cert", signers[1], checker.Authenticate},
} {
t.Run(tt.name, func(t *testing.T) {
a, b, err := netPipe()
if err != nil {
t.Fatalf("netPipe: %v", err)
}
defer a.Close()
defer b.Close()
serverConf := &ssh.ServerConfig{
PublicKeyAuthAlgorithms: []string{ssh.KeyAlgoMLDSA65},
PublicKeyCallback: tt.accept,
}
serverConf.AddHostKey(testSigners["ed25519"])
serverErr := make(chan error, 1)
go func() {
_, _, _, err := ssh.NewServerConn(a, serverConf)
serverErr <- err
}()
conn, _, _, err := ssh.NewClientConn(b, "", &ssh.ClientConfig{
User: "testuser",
Auth: []ssh.AuthMethod{ssh.PublicKeys(tt.signer)},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
})
if err != nil {
t.Fatalf("NewClientConn: %v (server: %v)", err, <-serverErr)
}
defer conn.Close()
if err := <-serverErr; err != nil {
t.Errorf("NewServerConn: %v", err)
}
})
}
}