//go:build !noawskms package awskms import ( "context" "crypto" "net/url" "strings" "time" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/kms" "github.com/aws/aws-sdk-go-v2/service/kms/types" "github.com/pkg/errors" "go.step.sm/crypto/kms/apiv1" "go.step.sm/crypto/kms/uri" "go.step.sm/crypto/pemutil" ) // Scheme is the scheme used in uris, the string "awskms". const Scheme = string(apiv1.AmazonKMS) // KMS implements a KMS using AWS Key Management Service. type KMS struct { client KeyManagementClient } // KeyManagementClient defines the methods on KeyManagementClient that this // package will use. This interface will be used for unit testing. type KeyManagementClient interface { GetPublicKey(ctx context.Context, input *kms.GetPublicKeyInput, opts ...func(*kms.Options)) (*kms.GetPublicKeyOutput, error) CreateKey(ctx context.Context, input *kms.CreateKeyInput, opts ...func(*kms.Options)) (*kms.CreateKeyOutput, error) CreateAlias(ctx context.Context, input *kms.CreateAliasInput, opts ...func(*kms.Options)) (*kms.CreateAliasOutput, error) Sign(ctx context.Context, input *kms.SignInput, opts ...func(*kms.Options)) (*kms.SignOutput, error) Decrypt(ctx context.Context, params *kms.DecryptInput, optFns ...func(*kms.Options)) (*kms.DecryptOutput, error) } // customerMasterKeySpecMapping is a mapping between the step signature algorithm, // and bits for RSA keys, with awskms CustomerMasterKeySpec. var customerMasterKeySpecMapping = map[apiv1.SignatureAlgorithm]interface{}{ apiv1.UnspecifiedSignAlgorithm: types.KeySpecEccNistP256, apiv1.SHA256WithRSA: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.SHA384WithRSA: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.SHA512WithRSA: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.SHA256WithRSAPSS: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.SHA384WithRSAPSS: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.SHA512WithRSAPSS: map[int]types.KeySpec{ 0: types.KeySpecRsa3072, 2048: types.KeySpecRsa2048, 3072: types.KeySpecRsa3072, 4096: types.KeySpecRsa4096, }, apiv1.ECDSAWithSHA256: types.KeySpecEccNistP256, apiv1.ECDSAWithSHA384: types.KeySpecEccNistP384, apiv1.ECDSAWithSHA512: types.KeySpecEccNistP521, } // New creates a new AWSKMS. By default, clients will be created using the // credentials in `~/.aws/credentials`, but this can be overridden using the // CredentialsFile option, the Region and Profile can also be configured as // options. // // AWS clients can also be configured with environment variables, see docs at // https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/ for all the // options. func New(ctx context.Context, opts apiv1.Options) (*KMS, error) { var configOptions []func(*config.LoadOptions) error if opts.URI != "" { u, err := uri.ParseWithScheme(Scheme, opts.URI) if err != nil { return nil, err } if v := u.Get("profile"); v != "" { configOptions = append(configOptions, config.WithSharedConfigProfile(v)) } if v := u.Get("region"); v != "" { configOptions = append(configOptions, config.WithRegion(v)) } if v := u.Get("credentials-file"); v != "" { configOptions = append(configOptions, config.WithSharedConfigFiles([]string{v})) } } // Deprecated way to set configuration parameters. if opts.Region != "" { configOptions = append(configOptions, config.WithRegion(opts.Region)) } if opts.Profile != "" { configOptions = append(configOptions, config.WithSharedConfigProfile(opts.Profile)) } if opts.CredentialsFile != "" { configOptions = append(configOptions, config.WithSharedConfigFiles([]string{opts.CredentialsFile})) } cfg, err := config.LoadDefaultConfig(ctx, configOptions...) if err != nil { return nil, errors.Wrap(err, "error loading AWS config") } return &KMS{ client: kms.NewFromConfig(cfg), }, nil } func init() { apiv1.Register(apiv1.AmazonKMS, func(ctx context.Context, opts apiv1.Options) (apiv1.KeyManager, error) { return New(ctx, opts) }) } // GetPublicKey returns a public key from KMS. func (k *KMS) GetPublicKey(req *apiv1.GetPublicKeyRequest) (crypto.PublicKey, error) { if req.Name == "" { return nil, errors.New("getPublicKey 'name' cannot be empty") } keyID, err := parseKeyID(req.Name) if err != nil { return nil, err } ctx, cancel := defaultContext() defer cancel() resp, err := k.client.GetPublicKey(ctx, &kms.GetPublicKeyInput{ KeyId: &keyID, }) if err != nil { return nil, errors.Wrap(err, "awskms GetPublicKey failed") } return pemutil.ParseDER(resp.PublicKey) } // CreateKey generates a new key in KMS and returns the public key version // of it. func (k *KMS) CreateKey(req *apiv1.CreateKeyRequest) (*apiv1.CreateKeyResponse, error) { if req.Name == "" { return nil, errors.New("createKeyRequest 'name' cannot be empty") } keyName, err := parseName(req.Name) if err != nil { return nil, err } keySpec, err := getCustomerMasterKeySpecMapping(req.SignatureAlgorithm, req.Bits) if err != nil { return nil, err } tag := types.Tag{ TagKey: pointer("name"), TagValue: pointer(keyName), } input := &kms.CreateKeyInput{ Description: pointer(keyName), KeySpec: keySpec, Tags: []types.Tag{tag}, KeyUsage: types.KeyUsageTypeSignVerify, } ctx, cancel := defaultContext() defer cancel() resp, err := k.client.CreateKey(ctx, input) if err != nil { return nil, errors.Wrap(err, "awskms CreateKey failed") } if err := k.createKeyAlias(*resp.KeyMetadata.KeyId, keyName); err != nil { return nil, err } // Create uri for key name := uri.New("awskms", url.Values{ "key-id": []string{*resp.KeyMetadata.KeyId}, }).String() publicKey, err := k.GetPublicKey(&apiv1.GetPublicKeyRequest{ Name: name, }) if err != nil { return nil, err } // Names uses Amazon Resource Name // https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html return &apiv1.CreateKeyResponse{ Name: name, PublicKey: publicKey, CreateSignerRequest: apiv1.CreateSignerRequest{ SigningKey: name, }, }, nil } func (k *KMS) createKeyAlias(keyID, alias string) error { ctx, cancel := defaultContext() defer cancel() _, err := k.client.CreateAlias(ctx, &kms.CreateAliasInput{ AliasName: pointer("alias/" + alias + "-" + keyID[:8]), TargetKeyId: pointer(keyID), }) if err != nil { return errors.Wrap(err, "awskms CreateAlias failed") } return nil } // CreateSigner creates a new crypto.Signer with a previously configured key. func (k *KMS) CreateSigner(req *apiv1.CreateSignerRequest) (crypto.Signer, error) { if req.SigningKey == "" { return nil, errors.New("createSigner 'signingKey' cannot be empty") } return NewSigner(k.client, req.SigningKey) } // Close closes the connection of the KMS client. func (k *KMS) Close() error { return nil } func pointer[T any](v T) *T { return &v } func defaultContext() (context.Context, context.CancelFunc) { return context.WithTimeout(context.Background(), 15*time.Second) } // parseKeyID extracts the key-id from an uri. func parseKeyID(name string) (string, error) { name = strings.ToLower(name) if strings.HasPrefix(name, "awskms:") || strings.HasPrefix(name, "aws:") { u, err := uri.Parse(name) if err != nil { return "", err } if k := u.Get("key-id"); k != "" { return k, nil } return "", errors.Errorf("failed to get key-id from %s", name) } return name, nil } // parseName extracts the name from an uri. func parseName(rawuri string) (string, error) { if strings.HasPrefix(rawuri, "awskms:") || strings.HasPrefix(rawuri, "aws:") { u, err := uri.Parse(rawuri) if err != nil { return "", err } if k := u.Get("name"); k != "" { return k, nil } return "", errors.Errorf("failed to get name from %s", rawuri) } return rawuri, nil } func getCustomerMasterKeySpecMapping(alg apiv1.SignatureAlgorithm, bits int) (types.KeySpec, error) { v, ok := customerMasterKeySpecMapping[alg] if !ok { return "", errors.Errorf("awskms does not support signature algorithm '%s'", alg) } switch v := v.(type) { case types.KeySpec: return v, nil case map[int]types.KeySpec: ks, ok := v[bits] if !ok { return "", errors.Errorf("awskms does not support signature algorithm '%s' with '%d' bits", alg, bits) } return ks, nil default: return "", errors.Errorf("unexpected error: this should not happen") } }