@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/httpclient/download_test.go

@@ -0,0 +1,374 @@
+package httpclient
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestNewDownloadRequestAppliesMediaDownloadPolicy(t *testing.T) {
+	t.Parallel()
+
+	req, err := NewDownloadRequest(context.Background(), http.MethodGet, "https://cdn.example.com/output.jpg", DownloadRequestOptions{
+		Accept:             "image/*",
+		UserAgent:          "OneX-Test/1.0",
+		DisableCompression: true,
+		Close:              true,
+	})
+	if err != nil {
+		t.Fatalf("NewDownloadRequest() error = %v", err)
+	}
+	if got := req.Header.Get("Accept"); got != "image/*" {
+		t.Fatalf("Accept header = %q, want image/*", got)
+	}
+	if got := req.Header.Get("User-Agent"); got != "OneX-Test/1.0" {
+		t.Fatalf("User-Agent header = %q, want OneX-Test/1.0", got)
+	}
+	if got := req.Header.Get("Accept-Encoding"); got != "identity" {
+		t.Fatalf("Accept-Encoding header = %q, want identity", got)
+	}
+	if !req.Close {
+		t.Fatalf("Close = false, want true")
+	}
+}
+
+func TestNewSingleUseTransportUsesDownloadSafeDefaults(t *testing.T) {
+	t.Parallel()
+
+	transport := NewSingleUseTransport(SingleUseTransportOptions{})
+	if !transport.DisableKeepAlives {
+		t.Fatalf("DisableKeepAlives = false, want true")
+	}
+	if transport.ForceAttemptHTTP2 {
+		t.Fatalf("ForceAttemptHTTP2 = true, want false")
+	}
+	if transport.ResponseHeaderTimeout != defaultDownloadResponseHeaderTimeout {
+		t.Fatalf("ResponseHeaderTimeout = %s, want %s", transport.ResponseHeaderTimeout, defaultDownloadResponseHeaderTimeout)
+	}
+	if transport.TLSHandshakeTimeout != defaultDownloadTLSHandshakeTimeout {
+		t.Fatalf("TLSHandshakeTimeout = %s, want %s", transport.TLSHandshakeTimeout, defaultDownloadTLSHandshakeTimeout)
+	}
+	if transport.TLSClientConfig == nil || transport.TLSClientConfig.MinVersion != tls.VersionTLS12 {
+		t.Fatalf("TLS MinVersion is not TLS 1.2")
+	}
+	if transport.TLSNextProto == nil {
+		t.Fatalf("TLSNextProto is nil, want HTTP/2 disabled map")
+	}
+	if transport.Proxy != nil {
+		t.Fatalf("Proxy is not nil")
+	}
+}
+
+func TestNewSingleUseTransportCanUseEnvironmentProxy(t *testing.T) {
+	t.Parallel()
+
+	transport := NewSingleUseTransport(SingleUseTransportOptions{ProxyFromEnvironment: true})
+	if transport.Proxy == nil {
+		t.Fatalf("Proxy is nil, want environment proxy")
+	}
+}
+
+func TestNewSingleUseTransportAcceptsTimeoutOverrides(t *testing.T) {
+	t.Parallel()
+
+	transport := NewSingleUseTransport(SingleUseTransportOptions{
+		ResponseHeaderTimeout: 7 * time.Second,
+		TLSHandshakeTimeout:   3 * time.Second,
+	})
+	if transport.ResponseHeaderTimeout != 7*time.Second {
+		t.Fatalf("ResponseHeaderTimeout = %s, want 7s", transport.ResponseHeaderTimeout)
+	}
+	if transport.TLSHandshakeTimeout != 3*time.Second {
+		t.Fatalf("TLSHandshakeTimeout = %s, want 3s", transport.TLSHandshakeTimeout)
+	}
+}
+
+func TestNewSafeDownloadClientRejectsUnsafeURLs(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name   string
+		rawURL string
+	}{
+		{name: "http_scheme", rawURL: "http://cdn.example.com/output.jpg"},
+		{name: "credentials", rawURL: "https://user:pass@cdn.example.com/output.jpg"},
+		{name: "loopback", rawURL: "https://127.0.0.1/output.jpg"},
+		{name: "private_ipv4", rawURL: "https://10.1.2.3/output.jpg"},
+		{name: "link_local", rawURL: "https://169.254.169.254/latest/meta-data"},
+		{name: "reserved_ipv6", rawURL: "https://[2001:db8::1]/output.jpg"},
+	}
+
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{
+		sendPinnedRequest: func(_ *http.Request, _ pinnedDownloadURL) (*http.Response, error) {
+			t.Fatalf("unsafe URL reached network")
+			return nil, nil
+		},
+	})
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			req, err := NewDownloadRequest(context.Background(), http.MethodGet, tc.rawURL, DownloadRequestOptions{})
+			if err != nil {
+				t.Fatalf("NewDownloadRequest() error = %v", err)
+			}
+			resp, err := client.Do(req)
+			if resp != nil {
+				defer resp.Body.Close()
+			}
+			if !IsSafeDownloadValidationError(err) {
+				t.Fatalf("client.Do() error = %v, want SafeDownloadValidationError", err)
+			}
+		})
+	}
+}
+
+func TestNewSafeDownloadClientValidatesAllResolvedAddresses(t *testing.T) {
+	t.Parallel()
+
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{
+		LookupIP: func(context.Context, string) ([]net.IP, error) {
+			return []net.IP{
+				net.ParseIP("93.184.216.34"),
+				net.ParseIP("10.0.0.8"),
+			}, nil
+		},
+		sendPinnedRequest: func(_ *http.Request, _ pinnedDownloadURL) (*http.Response, error) {
+			t.Fatalf("mixed public/private DNS result reached network")
+			return nil, nil
+		},
+	})
+
+	req, err := NewDownloadRequest(context.Background(), http.MethodGet, "https://cdn.example.com/output.jpg", DownloadRequestOptions{})
+	if err != nil {
+		t.Fatalf("NewDownloadRequest() error = %v", err)
+	}
+	resp, err := client.Do(req)
+	if resp != nil {
+		defer resp.Body.Close()
+	}
+	if !IsSafeDownloadValidationError(err) {
+		t.Fatalf("client.Do() error = %v, want SafeDownloadValidationError", err)
+	}
+}
+
+func TestNewSafeDownloadClientMarksDNSLookupFailureRetryable(t *testing.T) {
+	t.Parallel()
+
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{
+		LookupIP: func(context.Context, string) ([]net.IP, error) {
+			return nil, errors.New("transient DNS failure")
+		},
+		sendPinnedRequest: func(_ *http.Request, _ pinnedDownloadURL) (*http.Response, error) {
+			t.Fatalf("DNS failure reached network")
+			return nil, nil
+		},
+	})
+
+	req, err := NewDownloadRequest(context.Background(), http.MethodGet, "https://cdn.example.com/output.jpg", DownloadRequestOptions{})
+	if err != nil {
+		t.Fatalf("NewDownloadRequest() error = %v", err)
+	}
+	resp, err := client.Do(req)
+	if resp != nil {
+		defer resp.Body.Close()
+	}
+	if !IsSafeDownloadValidationError(err) {
+		t.Fatalf("client.Do() error = %v, want SafeDownloadValidationError", err)
+	}
+	if !IsSafeDownloadRetryableValidationError(err) {
+		t.Fatalf("client.Do() error = %v, want retryable validation error", err)
+	}
+}
+
+func TestNewSafeDownloadClientRevalidatesRedirectBeforeNextRequest(t *testing.T) {
+	t.Parallel()
+
+	var requestedHosts []string
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{
+		LookupIP: func(_ context.Context, hostname string) ([]net.IP, error) {
+			switch hostname {
+			case "first.example.com":
+				return []net.IP{net.ParseIP("93.184.216.34")}, nil
+			case "internal.example.com":
+				return []net.IP{net.ParseIP("127.0.0.1")}, nil
+			default:
+				t.Fatalf("unexpected hostname %q", hostname)
+				return nil, nil
+			}
+		},
+		sendPinnedRequest: func(req *http.Request, pinned pinnedDownloadURL) (*http.Response, error) {
+			requestedHosts = append(requestedHosts, pinned.URL.Hostname())
+			return &http.Response{
+				StatusCode: http.StatusFound,
+				Header:     http.Header{"Location": []string{"https://internal.example.com/output.jpg"}},
+				Body:       io.NopCloser(strings.NewReader("")),
+				Request:    req,
+			}, nil
+		},
+	})
+
+	req, err := NewDownloadRequest(context.Background(), http.MethodGet, "https://first.example.com/output.jpg", DownloadRequestOptions{})
+	if err != nil {
+		t.Fatalf("NewDownloadRequest() error = %v", err)
+	}
+	resp, err := client.Do(req)
+	if resp != nil {
+		defer resp.Body.Close()
+	}
+	if !IsSafeDownloadValidationError(err) {
+		t.Fatalf("client.Do() error = %v, want SafeDownloadValidationError", err)
+	}
+	if len(requestedHosts) != 1 || requestedHosts[0] != "first.example.com" {
+		t.Fatalf("requested hosts = %#v, want only first.example.com", requestedHosts)
+	}
+}
+
+func TestNewSafeDownloadClientFollowsPublicRedirectWithPinnedRequests(t *testing.T) {
+	t.Parallel()
+
+	var requestedHosts []string
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{
+		LookupIP: func(_ context.Context, hostname string) ([]net.IP, error) {
+			switch hostname {
+			case "first.example.com", "final.example.com":
+				return []net.IP{net.ParseIP("93.184.216.34")}, nil
+			default:
+				t.Fatalf("unexpected hostname %q", hostname)
+				return nil, nil
+			}
+		},
+		sendPinnedRequest: func(req *http.Request, pinned pinnedDownloadURL) (*http.Response, error) {
+			requestedHosts = append(requestedHosts, pinned.URL.Hostname())
+			if pinned.URL.Hostname() == "first.example.com" {
+				return &http.Response{
+					StatusCode: http.StatusTemporaryRedirect,
+					Header:     http.Header{"Location": []string{"https://final.example.com/output.jpg"}},
+					Body:       io.NopCloser(strings.NewReader("")),
+					Request:    req,
+				}, nil
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"image/jpeg"}},
+				Body:       io.NopCloser(strings.NewReader("image-bytes")),
+				Request:    req,
+			}, nil
+		},
+	})
+
+	req, err := NewDownloadRequest(context.Background(), http.MethodGet, "https://first.example.com/output.jpg", DownloadRequestOptions{})
+	if err != nil {
+		t.Fatalf("NewDownloadRequest() error = %v", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("client.Do() error = %v", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatalf("ReadAll() error = %v", err)
+	}
+	if string(body) != "image-bytes" {
+		t.Fatalf("body = %q, want image-bytes", string(body))
+	}
+	if got, want := resp.Request.URL.String(), "https://final.example.com/output.jpg"; got != want {
+		t.Fatalf("final URL = %q, want %q", got, want)
+	}
+	if got, want := strings.Join(requestedHosts, ","), "first.example.com,final.example.com"; got != want {
+		t.Fatalf("requested hosts = %q, want %q", got, want)
+	}
+}
+
+func TestNewSafeDownloadClientDisablesAutomaticRedirects(t *testing.T) {
+	t.Parallel()
+
+	client := NewSafeDownloadClient(SafeDownloadClientOptions{})
+	err := client.CheckRedirect(&http.Request{}, []*http.Request{})
+	if !errors.Is(err, http.ErrUseLastResponse) {
+		t.Fatalf("CheckRedirect() error = %v, want ErrUseLastResponse", err)
+	}
+}
+
+func TestNewDNSOverHTTPSLookupIPResolvesJSONAnswers(t *testing.T) {
+	t.Parallel()
+
+	seenQueries := make(map[string]bool)
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if got := r.Header.Get("Accept"); got != "application/dns-json" {
+			t.Fatalf("Accept header = %q, want application/dns-json", got)
+		}
+		if got := r.URL.Query().Get("name"); got != "cdn.example.com" {
+			t.Fatalf("name query = %q, want cdn.example.com", got)
+		}
+		queryType := r.URL.Query().Get("type")
+		seenQueries[queryType] = true
+		w.Header().Set("Content-Type", "application/dns-json")
+		switch queryType {
+		case "A":
+			_, _ = w.Write([]byte(`{"Status":0,"Answer":[{"type":5,"data":"edge.example.net"},{"type":1,"data":"93.184.216.34"}]}`))
+		case "AAAA":
+			_, _ = w.Write([]byte(`{"Status":0,"Answer":[{"type":28,"data":"2606:2800:220:1:248:1893:25c8:1946"}]}`))
+		default:
+			t.Fatalf("unexpected query type %q", queryType)
+		}
+	}))
+	defer server.Close()
+
+	lookupIP, err := NewDNSOverHTTPSLookupIP(DNSOverHTTPSLookupOptions{
+		Endpoint:   server.URL + "/dns-query",
+		HTTPClient: server.Client(),
+	})
+	if err != nil {
+		t.Fatalf("NewDNSOverHTTPSLookupIP() error = %v", err)
+	}
+	ips, err := lookupIP(context.Background(), "cdn.example.com")
+	if err != nil {
+		t.Fatalf("lookupIP() error = %v", err)
+	}
+	if len(ips) != 2 {
+		t.Fatalf("len(ips) = %d, want 2: %#v", len(ips), ips)
+	}
+	if got := ips[0].String(); got != "93.184.216.34" {
+		t.Fatalf("first IP = %q, want 93.184.216.34", got)
+	}
+	if got := ips[1].String(); got != "2606:2800:220:1:248:1893:25c8:1946" {
+		t.Fatalf("second IP = %q, want IPv6 answer", got)
+	}
+	if !seenQueries["A"] || !seenQueries["AAAA"] {
+		t.Fatalf("seen queries = %#v, want A and AAAA", seenQueries)
+	}
+}
+
+func TestNewDNSOverHTTPSLookupIPRejectsInvalidEndpoint(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name     string
+		endpoint string
+	}{
+		{name: "http_scheme", endpoint: "http://dns.example.com/dns-query"},
+		{name: "credentials", endpoint: "https://user:pass@dns.example.com/dns-query"},
+		{name: "missing_hostname", endpoint: "https:///dns-query"},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			_, err := NewDNSOverHTTPSLookupIP(DNSOverHTTPSLookupOptions{Endpoint: tc.endpoint})
+			if err == nil {
+				t.Fatalf("NewDNSOverHTTPSLookupIP() error = nil")
+			}
+		})
+	}
+}

package/dist/resources/templates/go-backend/internal/core/jwtkeyring/jwk.go

@@ -0,0 +1,38 @@
+package jwtkeyring
+
+import (
+	"encoding/base64"
+	"math/big"
+)
+
+// JSONWebKeySet 是 RFC 7517 公钥集合。
+type JSONWebKeySet struct {
+	Keys []JSONWebKey `json:"keys"`
+}
+
+// JSONWebKey 是 RSA 签名公钥的 RFC 7517 表示。
+type JSONWebKey struct {
+	KeyType   string `json:"kty"`
+	Use       string `json:"use"`
+	Algorithm string `json:"alg"`
+	KeyID     string `json:"kid"`
+	Modulus   string `json:"n"`
+	Exponent  string `json:"e"`
+}
+
+// JSONWebKeySet 返回当前密钥环的稳定公钥视图。
+func (r *KeyRing) JSONWebKeySet() JSONWebKeySet {
+	result := JSONWebKeySet{Keys: make([]JSONWebKey, 0)}
+	for _, keyID := range r.KeyIDs() {
+		key := r.publicKeys[keyID]
+		result.Keys = append(result.Keys, JSONWebKey{
+			KeyType:   "RSA",
+			Use:       "sig",
+			Algorithm: "RS256",
+			KeyID:     keyID,
+			Modulus:   base64.RawURLEncoding.EncodeToString(key.N.Bytes()),
+			Exponent:  base64.RawURLEncoding.EncodeToString(big.NewInt(int64(key.E)).Bytes()),
+		})
+	}
+	return result
+}

package/dist/resources/templates/go-backend/internal/core/jwtkeyring/keyring.go

@@ -0,0 +1,144 @@
+package jwtkeyring
+
+import (
+	"crypto/rsa"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+const minimumRSAKeyBits = 2048
+
+var keyIDPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$`)
+
+// Config 定义单个 RSA 签名域的密钥装载边界。
+type Config struct {
+	ActiveKeyID        string
+	PrivateKeyPath     string
+	PublicKeyDirectory string
+	RequirePrivateKey  bool
+}
+
+// KeyRing 保存一个签名域的活动私钥与可验证公钥集合。
+type KeyRing struct {
+	activeKeyID string
+	privateKey  *rsa.PrivateKey
+	publicKeys  map[string]*rsa.PublicKey
+}
+
+// Load 从只读文件系统装载并校验 RSA 密钥环。
+func Load(cfg Config) (*KeyRing, error) {
+	activeKeyID := strings.TrimSpace(cfg.ActiveKeyID)
+	if !keyIDPattern.MatchString(activeKeyID) {
+		return nil, fmt.Errorf("RSA key ring active key id is invalid")
+	}
+	publicKeys, err := loadPublicKeys(cfg.PublicKeyDirectory)
+	if err != nil {
+		return nil, err
+	}
+	activePublicKey, ok := publicKeys[activeKeyID]
+	if !ok {
+		return nil, fmt.Errorf("RSA key ring active public key %q is not configured", activeKeyID)
+	}
+
+	var privateKey *rsa.PrivateKey
+	if cfg.RequirePrivateKey {
+		privateKeyPath := strings.TrimSpace(cfg.PrivateKeyPath)
+		if privateKeyPath == "" {
+			return nil, fmt.Errorf("RSA key ring private key path is required")
+		}
+		privateKeyPEM, readErr := os.ReadFile(privateKeyPath)
+		if readErr != nil {
+			return nil, fmt.Errorf("read RSA private key: %w", readErr)
+		}
+		privateKey, err = jwt.ParseRSAPrivateKeyFromPEM(privateKeyPEM)
+		if err != nil {
+			return nil, fmt.Errorf("parse RSA private key: %w", err)
+		}
+		if privateKey.N.BitLen() < minimumRSAKeyBits {
+			return nil, fmt.Errorf("RSA private key must be at least %d bits", minimumRSAKeyBits)
+		}
+		if activePublicKey.E != privateKey.PublicKey.E || activePublicKey.N.Cmp(privateKey.PublicKey.N) != 0 {
+			return nil, fmt.Errorf("RSA active public key %q does not match signing key", activeKeyID)
+		}
+	}
+
+	return &KeyRing{activeKeyID: activeKeyID, privateKey: privateKey, publicKeys: publicKeys}, nil
+}
+
+// ActiveSigningKey 返回活动签名私钥；资源服务器不会装载该材料。
+func (r *KeyRing) ActiveSigningKey() (string, *rsa.PrivateKey, error) {
+	if r == nil || r.privateKey == nil {
+		return "", nil, fmt.Errorf("RSA signing key is unavailable in this process")
+	}
+	return r.activeKeyID, r.privateKey, nil
+}
+
+// VerificationKey 按 kid 精确返回验签公钥。
+func (r *KeyRing) VerificationKey(keyID string) (*rsa.PublicKey, bool) {
+	if r == nil || !IsCanonicalKeyID(keyID) {
+		return nil, false
+	}
+	key, ok := r.publicKeys[keyID]
+	return key, ok
+}
+
+// IsCanonicalKeyID 校验 JWT kid 是否可安全映射到密钥环文件名。
+func IsCanonicalKeyID(value string) bool {
+	return keyIDPattern.MatchString(value)
+}
+
+// KeyIDs 返回稳定排序的公钥标识。
+func (r *KeyRing) KeyIDs() []string {
+	if r == nil {
+		return nil
+	}
+	keyIDs := make([]string, 0, len(r.publicKeys))
+	for keyID := range r.publicKeys {
+		keyIDs = append(keyIDs, keyID)
+	}
+	sort.Strings(keyIDs)
+	return keyIDs
+}
+
+func loadPublicKeys(directory string) (map[string]*rsa.PublicKey, error) {
+	directory = strings.TrimSpace(directory)
+	if directory == "" {
+		return nil, fmt.Errorf("RSA public key directory is required")
+	}
+	entries, err := os.ReadDir(directory)
+	if err != nil {
+		return nil, fmt.Errorf("read RSA public key directory: %w", err)
+	}
+	keys := make(map[string]*rsa.PublicKey)
+	for _, entry := range entries {
+		if entry.IsDir() || strings.ToLower(filepath.Ext(entry.Name())) != ".pem" {
+			continue
+		}
+		keyID := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))
+		if !keyIDPattern.MatchString(keyID) {
+			return nil, fmt.Errorf("RSA public key id %q is invalid", keyID)
+		}
+		if _, duplicate := keys[keyID]; duplicate {
+			return nil, fmt.Errorf("RSA public key id %q is duplicated", keyID)
+		}
+		publicKeyPEM, readErr := os.ReadFile(filepath.Join(directory, entry.Name()))
+		if readErr != nil {
+			return nil, fmt.Errorf("read RSA public key %q: %w", keyID, readErr)
+		}
+		publicKey, parseErr := jwt.ParseRSAPublicKeyFromPEM(publicKeyPEM)
+		if parseErr != nil {
+			return nil, fmt.Errorf("parse RSA public key %q: %w", keyID, parseErr)
+		}
+		if publicKey.N.BitLen() < minimumRSAKeyBits {
+			return nil, fmt.Errorf("RSA public key %q must be at least %d bits", keyID, minimumRSAKeyBits)
+		}
+		keys[keyID] = publicKey
+	}
+	return keys, nil
+}

package/dist/resources/templates/go-backend/internal/core/jwtkeyring/keyring_test.go

@@ -0,0 +1,128 @@
+package jwtkeyring
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/json"
+	"encoding/pem"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadSupportsRotationAndPublishesPublicMaterialOnly(t *testing.T) {
+	activeKey := generateRSAKey(t)
+	previousKey := generateRSAKey(t)
+	publicDirectory := t.TempDir()
+	writePublicKey(t, publicDirectory, "key-previous", &previousKey.PublicKey)
+	writePublicKey(t, publicDirectory, "key-active", &activeKey.PublicKey)
+	privatePath := filepath.Join(t.TempDir(), "signing.pem")
+	writePrivateKey(t, privatePath, activeKey)
+
+	ring, err := Load(Config{
+		ActiveKeyID: "key-active", PrivateKeyPath: privatePath,
+		PublicKeyDirectory: publicDirectory, RequirePrivateKey: true,
+	})
+	require.NoError(t, err)
+	require.Equal(t, []string{"key-active", "key-previous"}, ring.KeyIDs())
+	keyID, signingKey, err := ring.ActiveSigningKey()
+	require.NoError(t, err)
+	require.Equal(t, "key-active", keyID)
+	require.Equal(t, activeKey.N, signingKey.N)
+	verificationKey, ok := ring.VerificationKey("key-previous")
+	require.True(t, ok)
+	require.Equal(t, previousKey.N, verificationKey.N)
+
+	encoded, err := json.Marshal(ring.JSONWebKeySet())
+	require.NoError(t, err)
+	var document struct {
+		Keys []map[string]any `json:"keys"`
+	}
+	require.NoError(t, json.Unmarshal(encoded, &document))
+	require.Len(t, document.Keys, 2)
+	for _, key := range document.Keys {
+		require.ElementsMatch(t, []string{"alg", "e", "kid", "kty", "n", "use"}, mapKeys(key))
+	}
+}
+
+func TestLoadRejectsPrivateKeyThatDoesNotMatchActivePublicKey(t *testing.T) {
+	activeKey := generateRSAKey(t)
+	otherKey := generateRSAKey(t)
+	publicDirectory := t.TempDir()
+	writePublicKey(t, publicDirectory, "key-active", &activeKey.PublicKey)
+	privatePath := filepath.Join(t.TempDir(), "signing.pem")
+	writePrivateKey(t, privatePath, otherKey)
+
+	_, err := Load(Config{
+		ActiveKeyID: "key-active", PrivateKeyPath: privatePath,
+		PublicKeyDirectory: publicDirectory, RequirePrivateKey: true,
+	})
+	require.ErrorContains(t, err, "does not match signing key")
+}
+
+func TestVerificationKeyRejectsNonCanonicalKeyIDs(t *testing.T) {
+	key := generateRSAKey(t)
+	directory := t.TempDir()
+	writePublicKey(t, directory, "key-active", &key.PublicKey)
+	ring, err := Load(Config{ActiveKeyID: "key-active", PublicKeyDirectory: directory})
+	require.NoError(t, err)
+	for _, keyID := range []string{" key-active", "key-active ", "key/active", strings.Repeat("a", 129)} {
+		_, ok := ring.VerificationKey(keyID)
+		require.False(t, ok, keyID)
+	}
+}
+
+func TestRegistryRejectsCrossDomainKeyIDCollisionAtomically(t *testing.T) {
+	sharedKey := generateRSAKey(t)
+	uniqueKey := generateRSAKey(t)
+	firstDirectory := t.TempDir()
+	writePublicKey(t, firstDirectory, "shared-key", &sharedKey.PublicKey)
+	firstRing, err := Load(Config{ActiveKeyID: "shared-key", PublicKeyDirectory: firstDirectory})
+	require.NoError(t, err)
+
+	secondDirectory := t.TempDir()
+	writePublicKey(t, secondDirectory, "shared-key", &sharedKey.PublicKey)
+	writePublicKey(t, secondDirectory, "unique-key", &uniqueKey.PublicKey)
+	secondRing, err := Load(Config{ActiveKeyID: "shared-key", PublicKeyDirectory: secondDirectory})
+	require.NoError(t, err)
+
+	registry := NewRegistry()
+	require.NoError(t, registry.Register("identity", firstRing))
+	err = registry.Register("iam", secondRing)
+	require.ErrorContains(t, err, "duplicated across signing domains")
+	require.Equal(t, []JSONWebKey{firstRing.JSONWebKeySet().Keys[0]}, registry.JSONWebKeySet().Keys)
+	require.Error(t, registry.Register("identity", firstRing))
+}
+
+func generateRSAKey(t *testing.T) *rsa.PrivateKey {
+	t.Helper()
+	key, err := rsa.GenerateKey(rand.Reader, minimumRSAKeyBits)
+	require.NoError(t, err)
+	return key
+}
+
+func writePrivateKey(t *testing.T, path string, key *rsa.PrivateKey) {
+	t.Helper()
+	encoded := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
+	require.NoError(t, os.WriteFile(path, encoded, 0o600))
+}
+
+func writePublicKey(t *testing.T, directory, keyID string, key *rsa.PublicKey) {
+	t.Helper()
+	der, err := x509.MarshalPKIXPublicKey(key)
+	require.NoError(t, err)
+	encoded := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: der})
+	require.NoError(t, os.WriteFile(filepath.Join(directory, keyID+".pem"), encoded, 0o600))
+}
+
+func mapKeys(value map[string]any) []string {
+	keys := make([]string, 0, len(value))
+	for key := range value {
+		keys = append(keys, key)
+	}
+	return keys
+}