Skeleton, mnemonic input, derivation, and the ssh pub and priv commands (closes #1)

The module, the script entrypoints and Makefile, Docker-only linting, the mnemonic sources in the specified order with their refusals, the BIP-85 derivation, and keyfunc ssh pub and priv with the README test vectors as tests. Two review rounds; the second passed with no findings.

Model: opus-5 (implementation and review); fable-5-1 (landing)

internal/sshkey/sshkey.go

@@ -0,0 +1,63 @@
+// Package sshkey turns derived bytes into an ed25519 SSH key.
+package sshkey
+
+import (
+	"crypto/ed25519"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"strings"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// Application is the number this key type occupies in the derivation
+// path. It spells SSH the way BIP-85 spells RSA, as the ASCII codes of
+// the letters written out.
+const Application = 838372
+
+// ErrSize is returned when the derived bytes are not the length an
+// ed25519 seed has to be.
+var ErrSize = errors.New("an ed25519 key needs 32 derived bytes")
+
+// Key is one ed25519 SSH key.
+type Key struct {
+	private ed25519.PrivateKey
+}
+
+// New makes a key whose ed25519 seed is the derived bytes.
+func New(derived []byte) (*Key, error) {
+	if len(derived) != ed25519.SeedSize {
+		return nil, fmt.Errorf("%w, got %d", ErrSize, len(derived))
+	}
+
+	return &Key{private: ed25519.NewKeyFromSeed(derived)}, nil
+}
+
+// Line returns the public key as one authorized_keys line, without a
+// trailing newline.
+func (k *Key) Line(comment string) (string, error) {
+	public, err := ssh.NewPublicKey(k.private.Public())
+	if err != nil {
+		return "", fmt.Errorf("encoding the public key: %w", err)
+	}
+
+	line := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(public)))
+
+	if comment != "" {
+		line += " " + comment
+	}
+
+	return line, nil
+}
+
+// Block returns the unencrypted private key in the OpenSSH format that
+// ssh reads, ending in a newline.
+func (k *Key) Block(comment string) (string, error) {
+	block, err := ssh.MarshalPrivateKey(k.private, comment)
+	if err != nil {
+		return "", fmt.Errorf("encoding the private key: %w", err)
+	}
+
+	return string(pem.EncodeToMemory(block)), nil
+}

internal/sshkey/sshkey_test.go

@@ -0,0 +1,68 @@
+package sshkey_test
+
+import (
+	"strings"
+	"testing"
+
+	"git.eeqj.de/sneak/keyfunc/internal/derive"
+	"git.eeqj.de/sneak/keyfunc/internal/sshkey"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/crypto/ssh"
+)
+
+// example returns the mnemonic every BIP-39 document uses to show its
+// test vectors: eleven abandons and about.
+func example() string {
+	return strings.Repeat("abandon ", 11) + "about"
+}
+
+func TestTooFewBytesAreRefused(t *testing.T) {
+	t.Parallel()
+
+	_, err := sshkey.New([]byte("short"))
+	require.ErrorIs(t, err, sshkey.ErrSize)
+}
+
+func TestTheCommentIsPutAtTheEndOfTheLine(t *testing.T) {
+	t.Parallel()
+
+	key := forIndex(t, 0)
+
+	line, err := key.Line("hello")
+	require.NoError(t, err)
+	require.True(t, strings.HasPrefix(line, "ssh-ed25519 "))
+	require.True(t, strings.HasSuffix(line, " hello"))
+}
+
+func TestThePrivateKeyCarriesTheSamePublicKey(t *testing.T) {
+	t.Parallel()
+
+	key := forIndex(t, 0)
+
+	line, err := key.Line("")
+	require.NoError(t, err)
+
+	block, err := key.Block("a comment")
+	require.NoError(t, err)
+
+	parsed, err := ssh.ParsePrivateKey([]byte(block))
+	require.NoError(t, err)
+
+	back := strings.TrimSpace(
+		string(ssh.MarshalAuthorizedKey(parsed.PublicKey())),
+	)
+	require.Equal(t, line, back)
+}
+
+// forIndex derives the key for one index.
+func forIndex(t *testing.T, index uint32) *sshkey.Key {
+	t.Helper()
+
+	material, err := derive.Bytes(example(), sshkey.Application, index)
+	require.NoError(t, err)
+
+	key, err := sshkey.New(material)
+	require.NoError(t, err)
+
+	return key
+}