go.step.sm/crypto v0.43.1: keyutil.GenerateSigner

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify go.step.sm/crypto/keyutil.GenerateSigner in pkg:golang/go.step.sm/crypto@v0.43.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.step.sm/crypto@v0.43.1
Demonstrate these symbols/APIs:
  - go.step.sm/crypto/keyutil.GenerateSigner

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:ec5291a5ed5632bc1354d6e382ebd149170fafa3f9c59a3e23ceddfe537bdec6","contract":["keyutil.GenerateSigner generates an ECDSA private key implementing crypto.Signer when given key type \"EC\" and curve \"P-256\", \"P-384\", or \"P-521\".","keyutil.GenerateSigner generates an RSA private key implementing crypto.Signer when given key type \"RSA\" and valid bit size such as 2048.","keyutil.GenerateSigner generates an Ed25519 private key implementing crypto.Signer when given key type \"OKP\" and curve \"Ed25519\".","keyutil.GenerateDefaultSigner generates a default ECDSA P-256 private key implementing crypto.Signer.","keyutil.GenerateSigner produces signers capable of creating cryptographic signatures via Sign and exposing Public keys.","keyutil.GenerateSigner returns an error when given an unrecognized key type or curve name."],"goal":"verify go.step.sm/crypto/keyutil.GenerateSigner in pkg:golang/go.step.sm/crypto@v0.43.1","kind":"HOW","packages":["pkg:golang/go.step.sm/crypto@v0.43.1"],"schemaVersion":1,"symbols":["go.step.sm/crypto/keyutil.GenerateSigner"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","executionContext":"go","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.step.sm/crypto@v0.43.1"],"schemaVersion":1,"subject":"pkg:golang/go.step.sm/crypto@v0.43.1","symbols":["go.step.sm/crypto/keyutil.GenerateSigner"],"verifierAdapter":"golang@1"}

module example.com/keyutilsigner

go 1.22.0

require go.step.sm/crypto v0.43.1

require (
	filippo.io/edwards25519 v1.1.0 // indirect
	github.com/pkg/errors v0.9.1 // indirect
	golang.org/x/crypto v0.19.0 // indirect
	golang.org/x/sys v0.17.0 // indirect
)

filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/smallstep/assert v0.0.0-20200723003110-82e2b9b3b262 h1:unQFBIznI+VYD1/1fApl1A+9VcBk+9dcqGfnePY87LY=
github.com/smallstep/assert v0.0.0-20200723003110-82e2b9b3b262/go.mod h1:MyOHs9Po2fbM1LHej6sBUT8ozbxmMOFG+E+rx/GSGuc=
go.step.sm/crypto v0.43.1 h1:18Z/M49SnFDPXvFbfoN/ugE1i0J7phLWARhSQs/XSDI=
go.step.sm/crypto v0.43.1/go.mod h1:9n90D/SWjH1hTyQn1hgviUGyK8YRv743S8UZHYbt4BU=
golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=

package keyutil_test

import (
	"crypto"
	"crypto/ecdsa"
	"crypto/ed25519"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"testing"

	"go.step.sm/crypto/keyutil"
)

func TestGenerateSigner_ECDSA(t *testing.T) {
	curves := []struct {
		name     string
		expected elliptic.Curve
	}{
		{"P-256", elliptic.P256()},
		{"P-384", elliptic.P384()},
		{"P-521", elliptic.P521()},
	}

	for _, tc := range curves {
		t.Run(tc.name, func(t *testing.T) {
			signer, err := keyutil.GenerateSigner("EC", tc.name, 0)
			if err != nil {
				t.Fatalf("GenerateSigner(EC, %s, 0) failed: %v", tc.name, err)
			}
			if signer == nil {
				t.Fatal("expected non-nil signer")
			}

			ecKey, ok := signer.(*ecdsa.PrivateKey)
			if !ok {
				t.Fatalf("expected *ecdsa.PrivateKey, got %T", signer)
			}
			if ecKey.Curve != tc.expected {
				t.Errorf("expected curve %v, got %v", tc.expected, ecKey.Curve)
			}

			// Verify public key
			pub := signer.Public()
			if pub == nil {
				t.Error("expected non-nil public key")
			}
			ecPub, ok := pub.(*ecdsa.PublicKey)
			if !ok || ecPub.Curve != tc.expected {
				t.Errorf("expected *ecdsa.PublicKey with curve %v", tc.expected)
			}

			// Sign and verify signature
			msg := []byte("payload to sign")
			digest := sha256.Sum256(msg)
			sig, err := signer.Sign(rand.Reader, digest[:], crypto.SHA256)
			if err != nil {
				t.Fatalf("Sign failed: %v", err)
			}
			if !ecdsa.VerifyASN1(ecPub, digest[:], sig) {
				t.Error("signature verification failed")
			}
		})
	}
}

func TestGenerateSigner_RSA(t *testing.T) {
	sizes := []int{2048, 3072}
	for _, size := range sizes {
		t.Run(fmt.Sprintf("%d", size), func(t *testing.T) {
			signer, err := keyutil.GenerateSigner("RSA", "", size)
			if err != nil {
				t.Fatalf("GenerateSigner(RSA, \"\", %d) failed: %v", size, err)
			}
			if signer == nil {
				t.Fatal("expected non-nil signer")
			}

			rsaKey, ok := signer.(*rsa.PrivateKey)
			if !ok {
				t.Fatalf("expected *rsa.PrivateKey, got %T", signer)
			}
			if rsaKey.N.BitLen() != size {
				t.Errorf("expected key size %d, got %d", size, rsaKey.N.BitLen())
			}

			pub := signer.Public()
			rsaPub, ok := pub.(*rsa.PublicKey)
			if !ok {
				t.Fatalf("expected *rsa.PublicKey, got %T", pub)
			}

			// Sign using PKCS1v15
			msg := []byte("rsa test payload")
			digest := sha256.Sum256(msg)
			sig, err := signer.Sign(rand.Reader, digest[:], crypto.SHA256)
			if err != nil {
				t.Fatalf("Sign failed: %v", err)
			}
			if err := rsa.VerifyPKCS1v15(rsaPub, crypto.SHA256, digest[:], sig); err != nil {
				t.Errorf("RSA signature verification failed: %v", err)
			}
		})
	}
}

func TestGenerateSigner_Ed25519(t *testing.T) {
	signer, err := keyutil.GenerateSigner("OKP", "Ed25519", 0)
	if err != nil {
		t.Fatalf("GenerateSigner(OKP, Ed25519, 0) failed: %v", err)
	}
	if signer == nil {
		t.Fatal("expected non-nil signer")
	}

	_, ok := signer.(ed25519.PrivateKey)
	if !ok {
		t.Fatalf("expected ed25519.PrivateKey, got %T", signer)
	}

	pub := signer.Public()
	edPub, ok := pub.(ed25519.PublicKey)
	if !ok {
		t.Fatalf("expected ed25519.PublicKey, got %T", pub)
	}

	msg := []byte("ed25519 message")
	sig, err := signer.Sign(rand.Reader, msg, crypto.Hash(0))
	if err != nil {
		t.Fatalf("Sign failed: %v", err)
	}
	if !ed25519.Verify(edPub, msg, sig) {
		t.Error("Ed25519 signature verification failed")
	}
}

func TestGenerateDefaultSigner(t *testing.T) {
	signer, err := keyutil.GenerateDefaultSigner()
	if err != nil {
		t.Fatalf("GenerateDefaultSigner() failed: %v", err)
	}
	if signer == nil {
		t.Fatal("expected non-nil signer")
	}

	ecKey, ok := signer.(*ecdsa.PrivateKey)
	if !ok {
		t.Fatalf("expected *ecdsa.PrivateKey, got %T", signer)
	}
	if ecKey.Curve != elliptic.P256() {
		t.Errorf("expected default curve P-256, got %v", ecKey.Curve)
	}
}

func TestGenerateSigner_UnsupportedKeyType(t *testing.T) {
	_, err := keyutil.GenerateSigner("INVALID_TYPE", "", 0)
	if err == nil {
		t.Fatal("expected error for unsupported key type, got nil")
	}

	_, err = keyutil.GenerateSigner("EC", "INVALID_CURVE", 0)
	if err == nil {
		t.Fatal("expected error for unsupported curve, got nil")
	}
}

{
  "schemaVersion": 1,
  "goal": "verify go.step.sm/crypto/keyutil.GenerateSigner in pkg:golang/go.step.sm/crypto@v0.43.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.step.sm/crypto@v0.43.1"
  ],
  "symbols": [
    "go.step.sm/crypto/keyutil.GenerateSigner"
  ]
}