diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 5217b38..3876f2b 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,9 +1,11 @@ -# A tag v is a release: GoReleaser builds every platform Terraform runs on, and signs the -# checksums with the GPG key registry.terraform.io holds for spin-stack, which is how the registry -# and every `terraform init` know the binaries are ours. +# A tag v is a release: GoReleaser builds every platform Terraform and OpenTofu run on, and +# signs the checksums with the key the registries hold for spin-stack - which is how every +# `init` knows the binaries are ours. # -# The key is the repository's GPG_PRIVATE_KEY and PASSPHRASE secrets, and its public half is in the -# registry's signing keys for spin-stack. Neither is set until a person publishes the provider. +# The key is in KMS (spin-stack/ci's signing.tf) and never leaves it: this job assumes the one role +# that may sign with it, which only the release environment's jobs may assume - and GitHub lets +# only a v* tag deploy to that environment. Its public half, for the registries, is +# `go run ./internal/cmd/kmspgp -key alias/terraform-provider-spin-signing public`. name: Release on: @@ -11,12 +13,18 @@ on: tags: ['v*'] permissions: - contents: write + contents: read jobs: release: runs-on: ubuntu-latest timeout-minutes: 30 + environment: release + permissions: + # The GitHub release and its files. + contents: write + # The OIDC token the signing role is assumed with. + id-token: write steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: @@ -25,17 +33,16 @@ jobs: - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7.0.0 with: go-version-file: go.mod + # This job signs: its Go comes from no cache another job saved. cache: false - - id: gpg - uses: crazy-max/ghaction-import-gpg@2dc316deee8e90f13e1a351ab510b4d5bc0c82cd # v7.0.0 + - uses: aws-actions/configure-aws-credentials@e1253824e5c10ff9df46874f81ed3ec929e19cfd # v6.3.0 with: - gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }} - passphrase: ${{ secrets.PASSPHRASE }} + role-to-assume: arn:aws:iam::277203350136:role/terraform-provider-spin-release + aws-region: us-west-2 - uses: goreleaser/goreleaser-action@a4f02ab5355a589de60d917a659ce617ed19b3de # v7.3.0 with: args: release --clean env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - GPG_FINGERPRINT: ${{ steps.gpg.outputs.fingerprint }} diff --git a/.gitignore b/.gitignore index 7da15aa..cee6f9b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ /_output/ /terraform-provider-spin +/dist/ diff --git a/.goreleaser.yml b/.goreleaser.yml index ed7425a..a55253f 100644 --- a/.goreleaser.yml +++ b/.goreleaser.yml @@ -1,6 +1,6 @@ -# What registry.terraform.io takes for a provider: a zip per platform named +# What registry.terraform.io and registry.opentofu.org take for a provider: a zip per platform named # terraform-provider-spin___.zip, the manifest, and SHA256SUMS signed by the key -# it holds for spin-stack. +# they hold for spin-stack. version: 2 before: hooks: @@ -28,8 +28,11 @@ checksum: name_template: '{{ .ProjectName }}_{{ .Version }}_SHA256SUMS' algorithm: sha256 signs: + # By the KMS key spin-stack/ci's signing.tf keeps, as the role this run assumed: kmspgp wraps what + # KMS signs in OpenPGP, as gpg --detach-sign would write it. - artifacts: checksum - args: ["--batch", "--local-user", "{{ .Env.GPG_FINGERPRINT }}", "--output", "${signature}", "--detach-sign", "${artifact}"] + cmd: go + args: ["run", "./internal/cmd/kmspgp", "-key", "alias/terraform-provider-spin-signing", "sign", "-out", "${signature}", "${artifact}"] release: extra_files: - glob: terraform-registry-manifest.json diff --git a/go.mod b/go.mod index e443d9f..2183b7b 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,10 @@ go 1.27.0 toolchain go1.27.4 require ( + github.com/ProtonMail/go-crypto v1.5.2 + github.com/aws/aws-sdk-go-v2 v1.48.0 + github.com/aws/aws-sdk-go-v2/config v1.33.19 + github.com/aws/aws-sdk-go-v2/service/kms v1.63.0 github.com/hashicorp/terraform-plugin-framework v1.19.0 github.com/hashicorp/terraform-plugin-go v0.31.0 github.com/hashicorp/terraform-plugin-testing v1.16.0 @@ -12,10 +16,21 @@ require ( ) require ( - github.com/ProtonMail/go-crypto v1.4.1 // indirect github.com/agext/levenshtein v1.2.3 // indirect github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.21.1 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.9 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.12 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.12 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.12 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.25 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.12 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.13.1 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.39.5 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.5 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.52.0 // indirect + github.com/aws/smithy-go v1.28.9 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cloudflare/circl v1.6.3 // indirect diff --git a/go.sum b/go.sum index 9347286..51f404f 100644 --- a/go.sum +++ b/go.sum @@ -36,8 +36,8 @@ github.com/AzureAD/microsoft-authentication-library-for-go v1.8.0 h1:Nljr4q1GRA/ github.com/AzureAD/microsoft-authentication-library-for-go v1.8.0/go.mod h1:Y33QHnf0FfdVewFFISOGe20mkZbxX4H839o955/PoeI= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/ProtonMail/go-crypto v1.4.1 h1:9RfcZHqEQUvP8RzecWEUafnZVtEvrBVL9BiF67IQOfM= -github.com/ProtonMail/go-crypto v1.4.1/go.mod h1:e1OaTyu5SYVrO9gKOEhTc+5UcXtTUa+P3uLudwcgPqo= +github.com/ProtonMail/go-crypto v1.5.2 h1:cucYnvqcY7UOXVD//mSyjeaPY0SSN3v5cDkYPxumINk= +github.com/ProtonMail/go-crypto v1.5.2/go.mod h1:/RaSu30DaKO4RY+XdV/ACcCcZkGr7AhUIduq5sjzzCo= github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo= github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= github.com/apparentlymart/go-textseg/v12 v12.0.0/go.mod h1:S/4uRK2UtaQttw1GenVJEynmyUenKwP++x/+DdGV/Ec= @@ -45,36 +45,36 @@ github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= -github.com/aws/aws-sdk-go-v2 v1.47.3 h1:HRoT/MkNi3bjO5xF4dCzLzvVmkvRGHj3/cLINDnJejk= -github.com/aws/aws-sdk-go-v2 v1.47.3/go.mod h1:xSl+OSI5ZUw6bSMupWc218zE5Pl+65MCCu3ySWFY99A= -github.com/aws/aws-sdk-go-v2/config v1.33.9 h1:Hv6bcQUJVnmuWaKjqD6Ot8sE75NrWsWV20oGT5aWle0= -github.com/aws/aws-sdk-go-v2/config v1.33.9/go.mod h1:ivowmrZNfBQLcg4QkaItgi5wae4Bzot9RzIdbY1hfTg= -github.com/aws/aws-sdk-go-v2/credentials v1.20.9 h1:SNO55PnWhaDafsOcv16lCA0kdoFMl/YlegWoVsU02s0= -github.com/aws/aws-sdk-go-v2/credentials v1.20.9/go.mod h1:+2reOTRtdD3VSBqpRDNwrZIYy8yMCYa7oK3WKTJ/I1I= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.3 h1:gr3b87OLB29jymWPzp/CAyXwQRJVE+sC4Wm0qBIKHsk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.3/go.mod h1:BRjf4L/Yx2hY54o+ZibPbLJyMMeSwqYQXwcJfqW66a8= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.6 h1:CqL8NN3p4I0JTwwV5MEoatIl4Y2amZ2X9dRD+0hbRL0= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.6/go.mod h1:exdJ32hMqXl0Wyo6NwqEC5yIhtua3+PDaKE8P29m4qE= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.6 h1:FpBq24TG6WVSObTNhQOv7Q0088rounUUlwn3zlNItkM= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.6/go.mod h1:ONzdPVYC95oBOu0VWNEsKEntcoemP3xVKjT+qWml1s4= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.6 h1:Qmn60RWuk9+bd2ddvJJqwf3Cpac3VvGMOdbGemtUhX4= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.6/go.mod h1:h/YJhe4AVyQxEUMluph10iqV7mjajH7A9L+BHF5ppis= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.21 h1:e6YW5uME30TkrElR+4/xcY7NB6CCj2dcv7vtmGXhfhQ= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.21/go.mod h1:obpHAMP693+f3/A8PkLhIqfK1C+NWWn8zXzqD3OH520= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.6 h1:LHHdobjo5le1sjJdolitV7uVvYg3wkaeM1Ju2fDgeZQ= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.6/go.mod h1:CBGB0evAiaMD3Lk4wPO7LQCcCZLuhzL5Qf/wfEUHQ5w= -github.com/aws/aws-sdk-go-v2/service/kms v1.61.4 h1:vW7497x7W6ucLJAqDt96jIdO4+IWLMB3p98UubwjdqM= -github.com/aws/aws-sdk-go-v2/service/kms v1.61.4/go.mod h1:Vz59N7x42VGLXZ5dGL9b10QhrU4GQv7MqnO7wc8bl9U= -github.com/aws/aws-sdk-go-v2/service/signin v1.10.4 h1:tvpDjuUvgKURf3Yk4hOaGbZ4QdY+070OWcA5d6LUv2A= -github.com/aws/aws-sdk-go-v2/service/signin v1.10.4/go.mod h1:3ibVKg5Ng82Zby8++jELTD2nHxiPk2DJRLEeW/LKp8M= -github.com/aws/aws-sdk-go-v2/service/sso v1.38.4 h1:ChCtagixSFOxltv0o6E3NT8F7ksvZtZGPwUBynO5Nmk= -github.com/aws/aws-sdk-go-v2/service/sso v1.38.4/go.mod h1:+FEO9jrVMpc9oN3CdAxJbtlQEu3z8UddDPSedpeM3PY= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.4 h1:j6c+HA4AoS0EBEjArPjavFEBrucJEryfrQU0TffmACk= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.4/go.mod h1:RhghaXUk9q66VtOQUX1FdPddQuHnqQZzbB0fEYXmPRA= -github.com/aws/aws-sdk-go-v2/service/sts v1.51.4 h1:OKEfbf2tcfsF2pBk/S9QqNpo6alaAtiBs4hysCsBjPw= -github.com/aws/aws-sdk-go-v2/service/sts v1.51.4/go.mod h1:mCd6qGo9b8hTtfjgsmNkFlzwjyce4owd7HDVFnCLXhM= -github.com/aws/smithy-go v1.28.5 h1:OqbqKtzY9NUnr2yAe9+hiTdFb20tNaK/lI0PMOGXX9k= -github.com/aws/smithy-go v1.28.5/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2 v1.48.0 h1:tFU7EJVm7MfyaXLsXdYTZ0Vd6vwt9OljCyqq0gqk0Mc= +github.com/aws/aws-sdk-go-v2 v1.48.0/go.mod h1:oeKU5p+TQBnpeLmU42WZLWvzv+ORLn+74n4QVLnm/Z0= +github.com/aws/aws-sdk-go-v2/config v1.33.19 h1:M0aPu5EdAMR6lGYN2GvM76WY0yqTyDi+gxV7s7Cdnr8= +github.com/aws/aws-sdk-go-v2/config v1.33.19/go.mod h1:FSZkRx5fOaq82bZkGZrK+dXFgWvI4iIE0Y6ADmEKDag= +github.com/aws/aws-sdk-go-v2/credentials v1.21.1 h1:4iuMmYSa42WMeClXjzE+HoZIeBud6o/bd00BN6WM9H4= +github.com/aws/aws-sdk-go-v2/credentials v1.21.1/go.mod h1:OffaVQod3fyZzhZJyPtw11WpHPF1uIHADc+/MYlXmbA= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.9 h1:oH1E0tjN0g+ZRusbX1dsuat4FJ0z05l8hWaycSbDuNc= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.9/go.mod h1:3ZaQGigIoaS45x9HgnLZ4sP475Fs7QoxU3IsZX/J3h4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.12 h1:W0yUUzKBA8SofGQ0yZafEUuZq9UxfvijRgdc6vcRQPA= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.12/go.mod h1:xwKv6vwBNdpPFOxEm/ld4IODZK2s/1ksHvdBqLfH6Gs= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.12 h1:lqSi8qvAnKC1vfosImdmOsuiJLr/jdybZX5299beB6Q= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.12/go.mod h1:rqPQE2vqkW9YHx5+Gp55sx1wsTM4xtGQLl+TKMjxxrs= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.12 h1:uvX2yaL+aMjkmnrLPPlR/zwjoKFRMoNhhJfeGjfk6qc= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.12/go.mod h1:dicT+2eNhHHqGkxHO7LoXw3QghIUGuzgdmFqaSTopgI= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.25 h1:rKwkY3Z+fvt2W0msjdNs6uNewPmXzPayQ961oyuWhes= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.25/go.mod h1:dBuAadQKd1F4Q4ZOg8gnFmuSHMRE40Pe3IfFwbtC4lE= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.12 h1:wzAqMZ2O4+ij9HQqIrk+P9PBGacE0wOTuWB7Mo97//I= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.12/go.mod h1:/0TfyruByHsOlphzP26xDTRe2DKD0J1I1Uyy2TyP8EI= +github.com/aws/aws-sdk-go-v2/service/kms v1.63.0 h1:Ovjb0ZSWfm+hPYFgU9BX0Oy7C/ob3EXbCrUUHo9Is98= +github.com/aws/aws-sdk-go-v2/service/kms v1.63.0/go.mod h1:VMuZyNobzmV/0SRCH5p+0dziD4U5AktOi3TzFMXq1rg= +github.com/aws/aws-sdk-go-v2/service/signin v1.13.1 h1:ssrDA6AKfXEc3h0Pf4EI4vQ8sN5Zd136SrU9Tjr0XPc= +github.com/aws/aws-sdk-go-v2/service/signin v1.13.1/go.mod h1:LdwHjKqPE9VCC7sTlWcOAizZx3ZJYjmfwC/EW2tIIAE= +github.com/aws/aws-sdk-go-v2/service/sso v1.39.5 h1:ANAoa+qt3/9kXnvQVgUyxcTzhzZf4DqaBS+M2DQrELU= +github.com/aws/aws-sdk-go-v2/service/sso v1.39.5/go.mod h1:vsMi+SSR7xGQXtV430LVi49qbv/R+U+upHHSp1W/+QI= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.5 h1:uIOBLMhef4N16WguadoHKuBy9etdz+RKTeqzchXErAI= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.5/go.mod h1:NwWmkFLtsTVyXQpbzPOlYLwEoANkdCFjJRtrNcbg/vY= +github.com/aws/aws-sdk-go-v2/service/sts v1.52.0 h1:IaBLmJWiIEtKkjXMgMbYGZk7WKXbYA8148wCMCXq9hU= +github.com/aws/aws-sdk-go-v2/service/sts v1.52.0/go.mod h1:MG6N8U9+lY4LqchrlHPqCOSr7hyxw70XU0Et2YR3eNA= +github.com/aws/smithy-go v1.28.9 h1:zkZ058OpNX0iGTK24b+ZUEQSMc11CBA6oO7xtKZfzkY= +github.com/aws/smithy-go v1.28.9/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw= github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c= github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= diff --git a/internal/cmd/kmspgp/main.go b/internal/cmd/kmspgp/main.go new file mode 100644 index 0000000..bed677b --- /dev/null +++ b/internal/cmd/kmspgp/main.go @@ -0,0 +1,94 @@ +// Command kmspgp signs a release's checksums with the provider's KMS key, as OpenPGP, and prints +// that key's public half for the registries: +// +// kmspgp -key alias/terraform-provider-spin-signing public # the armoured key, once per registry +// kmspgp -key alias/terraform-provider-spin-signing sign -out SHA256SUMS.sig SHA256SUMS +// +// AWS credentials are the SDK's own: the release workflow's role (spin-stack/ci's signing.tf). +package main + +import ( + "context" + "errors" + "flag" + "fmt" + "io" + "os" + "time" + + "github.com/aws/aws-sdk-go-v2/config" + "github.com/aws/aws-sdk-go-v2/service/kms" + + "github.com/spin-stack/terraform-provider-spin/internal/kmspgp" +) + +func main() { + if err := run(context.Background(), os.Args[1:], os.Stdout, newKMS); err != nil { // mutate-exempt: the process's own arguments; run is what the tests drive + fmt.Fprintln(os.Stderr, "kmspgp:", err) //nolint:errcheck // the exit status says it + os.Exit(1) // mutate-exempt: any status but 0 fails the release; run is what the tests drive + } +} + +func newKMS(ctx context.Context) (kmspgp.KMS, error) { + cfg, err := config.LoadDefaultConfig(ctx) + if err != nil { // mutate-exempt: reached only with AWS's own configuration, which the release's role is + return nil, fmt.Errorf("AWS credentials: %w", err) + } + return kmspgp.AWS{Client: kms.NewFromConfig(cfg)}, nil +} + +func run(ctx context.Context, args []string, stdout io.Writer, connect func(context.Context) (kmspgp.KMS, error)) error { + fs := flag.NewFlagSet("kmspgp", flag.ContinueOnError) + keyID := fs.String("key", "", "the KMS key: its id, ARN or alias") + if err := fs.Parse(args); err != nil { + return err + } + if *keyID == "" || fs.NArg() == 0 { + return errors.New("usage: kmspgp -key public | sign -out ") + } + k, err := connect(ctx) + if err != nil { + return err + } + signer, err := kmspgp.NewKMSSigner(ctx, k, *keyID) + if err != nil { + return err + } + key, err := kmspgp.New(signer, kmspgp.Created) + if err != nil { + return err + } + switch fs.Arg(0) { + case "public": + if _, err := fmt.Fprintf(stdout, "# %s, fingerprint %s\n", kmspgp.UserID, key.Fingerprint()); err != nil { + return err + } + return key.WritePublic(stdout) + case "sign": + return sign(key, fs.Args()[1:]) + default: + return fmt.Errorf("%q is neither public nor sign", fs.Arg(0)) + } +} + +func sign(key kmspgp.Key, args []string) (err error) { + fs := flag.NewFlagSet("sign", flag.ContinueOnError) + out := fs.String("out", "", "where the detached signature is written") + if err := fs.Parse(args); err != nil { + return err + } + if *out == "" || fs.NArg() != 1 { + return errors.New("usage: kmspgp -key sign -out ") + } + in, err := os.Open(fs.Arg(0)) + if err != nil { + return err + } + defer func() { _ = in.Close() }() // read only + w, err := os.Create(*out) + if err != nil { + return err + } + defer func() { err = errors.Join(err, w.Close()) }() + return key.Sign(w, in, time.Now()) +} diff --git a/internal/cmd/kmspgp/main_test.go b/internal/cmd/kmspgp/main_test.go new file mode 100644 index 0000000..4da4632 --- /dev/null +++ b/internal/cmd/kmspgp/main_test.go @@ -0,0 +1,106 @@ +package main + +import ( + "bytes" + "context" + "crypto" + "crypto/rand" + "crypto/rsa" + "errors" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/ProtonMail/go-crypto/openpgp" + + "github.com/spin-stack/terraform-provider-spin/internal/kmspgp" +) + +type localKMS struct{ key *rsa.PrivateKey } + +func (l localKMS) Sign(_ context.Context, _ string, digest []byte) ([]byte, error) { + return rsa.SignPKCS1v15(nil, l.key, crypto.SHA256, digest) +} + +func (l localKMS) PublicKey(context.Context, string) (*rsa.PublicKey, error) { + return &l.key.PublicKey, nil +} + +// The public key is printed for the registries, and a file signed with it is checked by it. +func TestThePublicKeySignsAndChecks(t *testing.T) { + k, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + t.Fatal(err) + } + connect := func(context.Context) (kmspgp.KMS, error) { return localKMS{k}, nil } + var pub bytes.Buffer + if err := run(t.Context(), []string{"-key", "alias/k", "public"}, &pub, connect); err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(pub.String(), "# "+kmspgp.UserID+", fingerprint ") || !strings.Contains(pub.String(), "BEGIN PGP PUBLIC KEY BLOCK") { + t.Fatalf("printed %s", pub.String()) + } + dir := t.TempDir() + sums := filepath.Join(dir, "SHA256SUMS") + if err := os.WriteFile(sums, []byte("sums\n"), 0o600); err != nil { + t.Fatal(err) + } + if err := run(t.Context(), []string{"-key", "alias/k", "sign", "-out", sums + ".sig", sums}, &bytes.Buffer{}, connect); err != nil { + t.Fatal(err) + } + ring, err := openpgp.ReadArmoredKeyRing(strings.NewReader(pub.String()[strings.Index(pub.String(), "-----BEGIN"):])) + if err != nil { + t.Fatal(err) + } + sig, err := os.ReadFile(sums + ".sig") + if err != nil { + t.Fatal(err) + } + if _, err := openpgp.CheckDetachedSignature(ring, strings.NewReader("sums\n"), bytes.NewReader(sig), nil); err != nil { + t.Fatal(err) + } +} + +// What is not a whole command signs nothing and says so. +func TestAnIncompleteCommandIsRefused(t *testing.T) { + k, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + t.Fatal(err) + } + connect := func(context.Context) (kmspgp.KMS, error) { return localKMS{k}, nil } + file := filepath.Join(t.TempDir(), "f") + if err := os.WriteFile(file, []byte("x"), 0o600); err != nil { + t.Fatal(err) + } + for name, args := range map[string][]string{ + "no out, said": {"-key", "alias/k", "sign", file}, + "two files": {"-key", "alias/k", "sign", "-out", file + ".sig", file, file}, + "no key": {"public"}, + "no verb": {"-key", "alias/k"}, + "another verb": {"-key", "alias/k", "verify"}, + "no out": {"-key", "alias/k", "sign", file}, + "no file": {"-key", "alias/k", "sign", "-out", file + ".sig"}, + "a missing file": {"-key", "alias/k", "sign", "-out", file + ".sig", file + ".none"}, + "no such flag": {"-nope"}, + "a bad sign flag": {"-key", "alias/k", "sign", "-nope"}, + "an unwritable signature": {"-key", "alias/k", "sign", "-out", filepath.Join(file, "x.sig"), file}, + } { + t.Run(name, func(t *testing.T) { + err := run(t.Context(), args, &bytes.Buffer{}, connect) + if err == nil { + t.Fatal("ran") + } + if strings.HasSuffix(name, ", said") || name == "two files" { + if !strings.Contains(err.Error(), "usage: kmspgp -key sign") { + t.Fatalf("err = %v, want the sign usage", err) + } + } + }) + } + if err := run(t.Context(), []string{"-key", "alias/k", "public"}, &bytes.Buffer{}, func(context.Context) (kmspgp.KMS, error) { + return nil, errors.New("no credentials") + }); err == nil || !strings.Contains(err.Error(), "no credentials") { + t.Fatalf("err = %v", err) + } +} diff --git a/internal/kmspgp/aws.go b/internal/kmspgp/aws.go new file mode 100644 index 0000000..8e1d76a --- /dev/null +++ b/internal/kmspgp/aws.go @@ -0,0 +1,58 @@ +package kmspgp + +import ( + "context" + "crypto/rsa" + "crypto/x509" + "fmt" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/kms" + kmstypes "github.com/aws/aws-sdk-go-v2/service/kms/types" +) + +// KMSAPI is what AWS answers for: the two calls a release makes of the key. +type KMSAPI interface { + Sign(ctx context.Context, in *kms.SignInput, opts ...func(*kms.Options)) (*kms.SignOutput, error) + GetPublicKey(ctx context.Context, in *kms.GetPublicKeyInput, opts ...func(*kms.Options)) (*kms.GetPublicKeyOutput, error) +} + +var _ KMSAPI = (*kms.Client)(nil) + +// AWS is KMS as the release workflow reaches it. +type AWS struct{ Client KMSAPI } + +// Sign is KMS's RSASSA-PKCS1-v1_5 signature over a SHA-256 digest computed here: the digest, not +// the message, goes to KMS. +func (a AWS) Sign(ctx context.Context, keyID string, digest []byte) ([]byte, error) { + out, err := a.Client.Sign(ctx, &kms.SignInput{ + KeyId: aws.String(keyID), + Message: digest, + MessageType: kmstypes.MessageTypeDigest, + SigningAlgorithm: kmstypes.SigningAlgorithmSpecRsassaPkcs1V15Sha256, + }) + if err != nil { + return nil, err + } + return out.Signature, nil +} + +// PublicKey is the key's RSA public half. +func (a AWS) PublicKey(ctx context.Context, keyID string) (*rsa.PublicKey, error) { + out, err := a.Client.GetPublicKey(ctx, &kms.GetPublicKeyInput{KeyId: aws.String(keyID)}) + if err != nil { + return nil, err + } + if out.KeyUsage != kmstypes.KeyUsageTypeSignVerify { + return nil, fmt.Errorf("%s is a key for %s, not for signing", keyID, out.KeyUsage) + } + pub, err := x509.ParsePKIXPublicKey(out.PublicKey) + if err != nil { + return nil, err + } + rsaPub, ok := pub.(*rsa.PublicKey) + if !ok { + return nil, fmt.Errorf("%s is a %T key, and the registries take RSA", keyID, pub) + } + return rsaPub, nil +} diff --git a/internal/kmspgp/aws_test.go b/internal/kmspgp/aws_test.go new file mode 100644 index 0000000..8b7f3c1 --- /dev/null +++ b/internal/kmspgp/aws_test.go @@ -0,0 +1,89 @@ +package kmspgp + +import ( + "context" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/x509" + "errors" + "strings" + "testing" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/kms" + kmstypes "github.com/aws/aws-sdk-go-v2/service/kms/types" +) + +type fakeAPI struct { + pub []byte + usage kmstypes.KeyUsageType + signed *kms.SignInput + fail error +} + +func (f *fakeAPI) Sign(_ context.Context, in *kms.SignInput, _ ...func(*kms.Options)) (*kms.SignOutput, error) { + f.signed = in + if f.fail != nil { + return nil, f.fail + } + return &kms.SignOutput{Signature: []byte("signature")}, nil +} + +func (f *fakeAPI) GetPublicKey(context.Context, *kms.GetPublicKeyInput, ...func(*kms.Options)) (*kms.GetPublicKeyOutput, error) { + if f.fail != nil { + return nil, f.fail + } + return &kms.GetPublicKeyOutput{PublicKey: f.pub, KeyUsage: f.usage}, nil +} + +func der(t *testing.T, pub any) []byte { + t.Helper() + b, err := x509.MarshalPKIXPublicKey(pub) + if err != nil { + t.Fatal(err) + } + return b +} + +// KMS is asked to sign the digest it is handed, as RSASSA-PKCS1-v1_5 over SHA-256, and its key is +// taken only as an RSA signing key. +func TestKMSIsAskedForAnRSASignatureOverTheDigest(t *testing.T) { + f := &fakeAPI{pub: der(t, &testKey.PublicKey), usage: kmstypes.KeyUsageTypeSignVerify} + a := AWS{Client: f} + pub, err := a.PublicKey(t.Context(), "alias/k") + if err != nil || pub.N.Cmp(testKey.N) != 0 { + t.Fatalf("public key %v, %v", pub, err) + } + sig, err := a.Sign(t.Context(), "alias/k", []byte("digest")) + if err != nil || string(sig) != "signature" { + t.Fatalf("signature %q, %v", sig, err) + } + if aws.ToString(f.signed.KeyId) != "alias/k" || string(f.signed.Message) != "digest" || + f.signed.MessageType != kmstypes.MessageTypeDigest || f.signed.SigningAlgorithm != kmstypes.SigningAlgorithmSpecRsassaPkcs1V15Sha256 { + t.Fatalf("asked %+v", f.signed) + } + + ec, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + t.Fatal(err) + } + for name, tc := range map[string]struct { + api *fakeAPI + says string + }{ + "an encryption key": {&fakeAPI{pub: der(t, &testKey.PublicKey), usage: kmstypes.KeyUsageTypeEncryptDecrypt}, "not for signing"}, + "an ECDSA key": {&fakeAPI{pub: der(t, &ec.PublicKey), usage: kmstypes.KeyUsageTypeSignVerify}, "take RSA"}, + "not a key": {&fakeAPI{pub: []byte("x"), usage: kmstypes.KeyUsageTypeSignVerify}, "asn1"}, + "refused": {&fakeAPI{fail: errors.New("AccessDenied")}, "AccessDenied"}, + } { + t.Run(name, func(t *testing.T) { + if _, err := (AWS{Client: tc.api}).PublicKey(t.Context(), "alias/k"); err == nil || !strings.Contains(err.Error(), tc.says) { + t.Fatalf("err = %v, want %q", err, tc.says) + } + }) + } + if _, err := (AWS{Client: &fakeAPI{fail: errors.New("throttled")}}).Sign(t.Context(), "alias/k", nil); err == nil { + t.Fatal("a refused signature was answered") + } +} diff --git a/internal/kmspgp/kmspgp.go b/internal/kmspgp/kmspgp.go new file mode 100644 index 0000000..045016e --- /dev/null +++ b/internal/kmspgp/kmspgp.go @@ -0,0 +1,160 @@ +// Package kmspgp is an OpenPGP key whose private half is a KMS key: the Terraform and OpenTofu +// registries take a provider's release only when an OpenPGP key they hold signs its SHA256SUMS, +// and spin-stack keeps no private key anywhere but KMS (spin-stack/ci's signing.tf). +// +// The key is the KMS key's RSA public key and a creation time, and its user id is self-signed by +// KMS: the same KMS key and the same time are always the same OpenPGP key - its fingerprint, its +// armour byte for byte - so the public key a registry was given once is the one every release is +// checked against. +package kmspgp + +import ( + "context" + "crypto" + "crypto/rsa" + "errors" + "fmt" + "io" + "time" + + "github.com/ProtonMail/go-crypto/openpgp" + "github.com/ProtonMail/go-crypto/openpgp/armor" + "github.com/ProtonMail/go-crypto/openpgp/packet" +) + +// Created is when the key is said to have been made: part of its fingerprint, so never moved. +var Created = time.Date(2026, 11, 17, 0, 0, 0, 0, time.UTC) + +// Who the key says it is: UserID, as OpenPGP spells a name and a comment. +const ( + name = "spin-stack" + comment = "terraform-provider-spin releases" + UserID = name + " (" + comment + ")" +) + +// Signer is the RSA key that signs: KMS's, or a test's. +type Signer interface { + crypto.Signer +} + +// Key is the OpenPGP key of signer. +type Key struct { + entity *openpgp.Entity + config *packet.Config +} + +// New is signer's OpenPGP key, created at created, its user id self-signed by signer. +func New(signer Signer, created time.Time) (Key, error) { + pub, ok := signer.Public().(*rsa.PublicKey) + if !ok { + return Key{}, fmt.Errorf("kmspgp: the key is %T, and the registries take RSA", signer.Public()) + } + // No salt notation: go-crypto salts v4 signatures by default, which guards EdDSA against faults + // and does nothing for RSA PKCS#1 v1.5, and would make the self-signature - so the public key a + // registry holds - another each time it is printed. + deterministic := false + cfg := &packet.Config{DefaultHash: crypto.SHA256, Time: func() time.Time { return created }, NonDeterministicSignaturesViaNotation: &deterministic} + primary := packet.NewRSAPublicKey(created, pub) + // Built here, not by packet.NewSignerPrivateKey, which takes a key it holds and no other: what + // signs is priv.PrivateKey as a crypto.Signer, which KMS's is. + priv := &packet.PrivateKey{PublicKey: *primary, PrivateKey: signer} + uid := packet.NewUserId(name, comment, "") + if uid == nil { + return Key{}, errors.New("kmspgp: the user id is not one") + } + primaryID := true + self := &packet.Signature{ + Version: 4, // mutate-exempt: go-crypto signs with the key's own version, and the test holds it to 4 + SigType: packet.SigTypePositiveCert, + PubKeyAlgo: packet.PubKeyAlgoRSA, + Hash: crypto.SHA256, + CreationTime: created, + IssuerKeyId: &primary.KeyId, + IsPrimaryId: &primaryID, + FlagsValid: true, + FlagSign: true, + FlagCertify: true, + } + if err := self.SignUserId(uid.Id, primary, priv, cfg); err != nil { + return Key{}, fmt.Errorf("kmspgp: self-signing the user id: %w", err) + } + e := &openpgp.Entity{ + PrimaryKey: primary, + PrivateKey: priv, + Identities: map[string]*openpgp.Identity{uid.Id: { + Name: uid.Id, UserId: uid, SelfSignature: self, Signatures: []*packet.Signature{self}, + }}, + } + return Key{entity: e, config: cfg}, nil +} + +// Fingerprint is the key's, in upper-case hex as the registries show it. +func (k Key) Fingerprint() string { return fmt.Sprintf("%X", k.entity.PrimaryKey.Fingerprint) } + +// WritePublic writes the armoured public key: what a registry is given once. +func (k Key) WritePublic(w io.Writer) error { + a, err := armor.Encode(w, openpgp.PublicKeyType, nil) + if err != nil { + return err + } + if err := k.entity.Serialize(a); err != nil { + return fmt.Errorf("kmspgp: %w", err) + } + return a.Close() +} + +// Sign writes the detached binary signature of message: GoReleaser's .sig, as gpg +// --detach-sign writes it. +func (k Key) Sign(w io.Writer, message io.Reader, at time.Time) error { + cfg := *k.config + cfg.Time = func() time.Time { return at } + if err := openpgp.DetachSign(w, k.entity, message, &cfg); err != nil { + // go-crypto drops the signer's own error (a shadowed err in Signature.Sign) and answers that + // nothing was signed: what KMS said is the reason worth saying. + if s, ok := k.entity.PrivateKey.PrivateKey.(*kmsSigner); ok && s.failed != nil { + err = s.failed + } + return fmt.Errorf("kmspgp: %w", err) + } + return nil +} + +// KMS is what Sign asks of AWS KMS: its signature over a digest, and the key's public half. +type KMS interface { + Sign(ctx context.Context, keyID string, digest []byte) ([]byte, error) + PublicKey(ctx context.Context, keyID string) (*rsa.PublicKey, error) +} + +// kmsSigner is a crypto.Signer whose private key is the KMS key keyID: RSASSA-PKCS1-v1_5 over a +// SHA-256 digest, which is what an OpenPGP RSA signature is. +type kmsSigner struct { + ctx context.Context //nolint:containedctx // crypto.Signer takes none, and each Sign is one call under it + kms KMS + keyID string + pub *rsa.PublicKey + // failed is KMS's last refusal, which go-crypto does not pass on. + failed error +} + +// NewKMSSigner is the KMS key keyID as a crypto.Signer. +func NewKMSSigner(ctx context.Context, k KMS, keyID string) (Signer, error) { + pub, err := k.PublicKey(ctx, keyID) + if err != nil { + return nil, fmt.Errorf("kmspgp: %s's public key: %w", keyID, err) + } + return &kmsSigner{ctx: ctx, kms: k, keyID: keyID, pub: pub}, nil +} + +func (s *kmsSigner) Public() crypto.PublicKey { return s.pub } + +func (s *kmsSigner) Sign(_ io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) { + if opts.HashFunc() != crypto.SHA256 { + return nil, fmt.Errorf("kmspgp: KMS is asked for SHA-256 signatures, and this is %v", opts.HashFunc()) + } + sig, err := s.kms.Sign(s.ctx, s.keyID, digest) + if err != nil { + s.failed = fmt.Errorf("KMS's signature: %w", err) + return nil, s.failed + } + return sig, nil +} diff --git a/internal/kmspgp/kmspgp_test.go b/internal/kmspgp/kmspgp_test.go new file mode 100644 index 0000000..f1c3b99 --- /dev/null +++ b/internal/kmspgp/kmspgp_test.go @@ -0,0 +1,212 @@ +package kmspgp + +import ( + "bytes" + "context" + "crypto" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/rsa" + "crypto/sha256" + "errors" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/ProtonMail/go-crypto/openpgp" + "github.com/ProtonMail/go-crypto/openpgp/packet" +) + +// fakeKMS is KMS with the private key here: a test's, signing as KMS's RSASSA_PKCS1_V1_5_SHA_256 +// does over a digest it is given. +type fakeKMS struct { + key *rsa.PrivateKey + signs int + fail error +} + +func (f *fakeKMS) Sign(_ context.Context, _ string, digest []byte) ([]byte, error) { + f.signs++ + if f.fail != nil { + return nil, f.fail + } + return rsa.SignPKCS1v15(nil, f.key, crypto.SHA256, digest) +} + +func (f *fakeKMS) PublicKey(context.Context, string) (*rsa.PublicKey, error) { + if f.fail != nil { + return nil, f.fail + } + return &f.key.PublicKey, nil +} + +var testKey = func() *rsa.PrivateKey { + k, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + panic(err) + } + return k +}() + +func key(t *testing.T, f *fakeKMS) Key { + t.Helper() + s, err := NewKMSSigner(t.Context(), f, "alias/test") + if err != nil { + t.Fatal(err) + } + k, err := New(s, Created) + if err != nil { + t.Fatal(err) + } + return k +} + +func public(t *testing.T, k Key) []byte { + t.Helper() + var b bytes.Buffer + if err := k.WritePublic(&b); err != nil { + t.Fatal(err) + } + return b.Bytes() +} + +// What KMS signs is a signature anybody holding the public key checks, over these bytes and no +// others: the registries' check of a release. +func TestASignatureChecksAgainstThePublicKey(t *testing.T) { + f := &fakeKMS{key: testKey} + k := key(t, f) + sums := []byte("e3b0c442 terraform-provider-spin_0.1.0_linux_amd64.zip\n") + var sig bytes.Buffer + at := time.Now().Add(-time.Hour).Truncate(time.Second) + if err := k.Sign(&sig, bytes.NewReader(sums), at); err != nil { + t.Fatal(err) + } + // Signed when the release was, not when the key was made. + p, err := packet.Read(bytes.NewReader(sig.Bytes())) + if err != nil { + t.Fatal(err) + } + if s, ok := p.(*packet.Signature); !ok || !s.CreationTime.Equal(at) { + t.Fatalf("the signature is %T made %v, want one made %v", p, s.CreationTime, at) + } + ring, err := openpgp.ReadArmoredKeyRing(bytes.NewReader(public(t, k))) + if err != nil { + t.Fatal(err) + } + signer, err := openpgp.CheckDetachedSignature(ring, bytes.NewReader(sums), bytes.NewReader(sig.Bytes()), nil) + if err != nil { + t.Fatal(err) + } + if _, ok := signer.Identities[UserID]; !ok { + t.Fatalf("signed by %v", signer.Identities) + } + if _, err := openpgp.CheckDetachedSignature(ring, strings.NewReader("other bytes"), bytes.NewReader(sig.Bytes()), nil); err == nil { + t.Fatal("the signature checks over other bytes") + } +} + +// GnuPG, which is what the registries' instructions verify with, takes the key and the signature: +// the format is OpenPGP's, not this package's idea of it. +func TestGnuPGVerifiesTheSignature(t *testing.T) { + gpg, err := exec.LookPath("gpg") + if err != nil { + t.Skip("no gpg on PATH") + } + k := key(t, &fakeKMS{key: testKey}) + home := t.TempDir() + dir := t.TempDir() + sums := filepath.Join(dir, "SHA256SUMS") + if err := os.WriteFile(sums, []byte("sums\n"), 0o600); err != nil { + t.Fatal(err) + } + f, err := os.Create(sums + ".sig") + if err != nil { + t.Fatal(err) + } + in, err := os.Open(sums) + if err != nil { + t.Fatal(err) + } + if err := k.Sign(f, in, time.Now()); err != nil { + t.Fatal(err) + } + _ = in.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } + imp := exec.Command(gpg, "--homedir", home, "--batch", "--import") + imp.Stdin = bytes.NewReader(public(t, k)) + if out, err := imp.CombinedOutput(); err != nil { + t.Fatalf("gpg --import: %v: %s", err, out) + } + if out, err := exec.Command(gpg, "--homedir", home, "--batch", "--verify", sums+".sig", sums).CombinedOutput(); err != nil || + !strings.Contains(string(out), "Good signature from \""+UserID+"\"") { + t.Fatalf("gpg --verify: %v: %s", err, out) + } + if err := os.WriteFile(sums, []byte("other\n"), 0o600); err != nil { + t.Fatal(err) + } + if out, err := exec.Command(gpg, "--homedir", home, "--batch", "--verify", sums+".sig", sums).CombinedOutput(); err == nil { + t.Fatalf("gpg verified other bytes: %s", out) + } +} + +// The same KMS key and creation time are the same OpenPGP key, byte for byte: what a registry was +// given once is what every release after is checked against. Another time is another key. +func TestTheKeyIsItsKMSKeyAndTime(t *testing.T) { + a, b := key(t, &fakeKMS{key: testKey}), key(t, &fakeKMS{key: testKey}) + if !bytes.Equal(public(t, a), public(t, b)) || a.Fingerprint() != b.Fingerprint() || len(a.Fingerprint()) != 40 { + t.Fatalf("fingerprints %s and %s", a.Fingerprint(), b.Fingerprint()) + } + // A version 4 key and self-signature: what Terraform's OpenPGP reads, which knows no later one. + ring, err := openpgp.ReadArmoredKeyRing(bytes.NewReader(public(t, a))) + if err != nil { + t.Fatal(err) + } + if e := ring[0]; e.PrimaryKey.Version != 4 || e.Identities[UserID].SelfSignature.Version != 4 { + t.Fatalf("key version %d, self-signature version %d", e.PrimaryKey.Version, e.Identities[UserID].SelfSignature.Version) + } + s, err := NewKMSSigner(t.Context(), &fakeKMS{key: testKey}, "alias/test") + if err != nil { + t.Fatal(err) + } + later, err := New(s, Created.Add(time.Hour)) + if err != nil { + t.Fatal(err) + } + if later.Fingerprint() == a.Fingerprint() { + t.Fatal("another creation time is the same key") + } +} + +// What KMS refuses, and what is not RSA over SHA-256, signs nothing. +func TestWhatKMSCannotSignIsRefused(t *testing.T) { + if _, err := NewKMSSigner(t.Context(), &fakeKMS{key: testKey, fail: errors.New("AccessDenied")}, "alias/test"); err == nil || !strings.Contains(err.Error(), "AccessDenied") { + t.Fatalf("err = %v", err) + } + f := &fakeKMS{key: testKey} + k := key(t, f) + f.fail = errors.New("throttled") + if err := k.Sign(&bytes.Buffer{}, strings.NewReader("x"), time.Now()); err == nil || !strings.Contains(err.Error(), "throttled") { + t.Fatalf("err = %v", err) + } + s, err := NewKMSSigner(t.Context(), &fakeKMS{key: testKey}, "alias/test") + if err != nil { + t.Fatal(err) + } + sum := sha256.Sum256([]byte("x")) + if _, err := s.Sign(nil, sum[:], crypto.SHA512); err == nil { + t.Fatal("signed as SHA-512, which KMS is not asked for") + } + ec, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + t.Fatal(err) + } + if _, err := New(ec, Created); err == nil || !strings.Contains(err.Error(), "RSA") { + t.Fatalf("an ECDSA key: %v", err) + } +}