| 1 |
// |
| 2 |
// Copyright 2021 The Sigstore Authors. |
| 3 |
// |
| 4 |
// Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 |
// you may not use this file except in compliance with the License. |
| 6 |
// You may obtain a copy of the License at |
| 7 |
// |
| 8 |
// http://www.apache.org/licenses/LICENSE-2.0 |
| 9 |
// |
| 10 |
// Unless required by applicable law or agreed to in writing, software |
| 11 |
// distributed under the License is distributed on an "AS IS" BASIS, |
| 12 |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 |
// See the License for the specific language governing permissions and |
| 14 |
// limitations under the License. |
| 15 |
|
| 16 |
// Package aws implement the interface with amazon aws kms service |
| 17 |
package aws |
| 18 |
|
| 19 |
import ( |
| 20 |
"context" |
| 21 |
"crypto" |
| 22 |
"crypto/ecdsa" |
| 23 |
"crypto/rsa" |
| 24 |
"crypto/tls" |
| 25 |
"crypto/x509" |
| 26 |
"errors" |
| 27 |
"fmt" |
| 28 |
"io" |
| 29 |
"net/http" |
| 30 |
"os" |
| 31 |
"regexp" |
| 32 |
"time" |
| 33 |
|
| 34 |
"github.com/aws/aws-sdk-go-v2/aws" |
| 35 |
"github.com/aws/aws-sdk-go-v2/config" |
| 36 |
"github.com/aws/aws-sdk-go-v2/service/kms" |
| 37 |
"github.com/aws/aws-sdk-go-v2/service/kms/types" |
| 38 |
"github.com/jellydator/ttlcache/v3" |
| 39 |
"github.com/sigstore/sigstore/pkg/signature" |
| 40 |
sigkms "github.com/sigstore/sigstore/pkg/signature/kms" |
| 41 |
) |
| 42 |
|
| 43 |
func init() { |
| 44 |
sigkms.AddProvider(ReferenceScheme, func(ctx context.Context, keyResourceID string, _ crypto.Hash, _ ...signature.RPCOption) (sigkms.SignerVerifier, error) { |
| 45 |
return LoadSignerVerifier(ctx, keyResourceID) |
| 46 |
}) |
| 47 |
} |
| 48 |
|
| 49 |
const ( |
| 50 |
cacheKey = "signer" |
| 51 |
// ReferenceScheme schemes for various KMS services are copied from https://github.com/google/go-cloud/tree/master/secrets |
| 52 |
ReferenceScheme = "awskms://" |
| 53 |
) |
| 54 |
|
| 55 |
type awsClient struct { |
| 56 |
client *kms.Client |
| 57 |
endpoint string |
| 58 |
keyID string |
| 59 |
alias string |
| 60 |
keyCache *ttlcache.Cache[string, cmk] |
| 61 |
} |
| 62 |
|
| 63 |
var ( |
| 64 |
errKMSReference = errors.New("kms specification should be in the format awskms://[ENDPOINT]/[ID/ALIAS/ARN] (endpoint optional)") |
| 65 |
|
| 66 |
// Key ID/ALIAS/ARN conforms to KMS standard documented here: https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id |
| 67 |
// Key format examples: |
| 68 |
// Key ID: awskms:///1234abcd-12ab-34cd-56ef-1234567890ab |
| 69 |
// Key ID with endpoint: awskms://localhost:4566/1234abcd-12ab-34cd-56ef-1234567890ab |
| 70 |
// Key ARN: awskms:///arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab |
| 71 |
// Key ARN with endpoint: awskms://localhost:4566/arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab |
| 72 |
// Alias name: awskms:///alias/ExampleAlias |
| 73 |
// Alias name with endpoint: awskms://localhost:4566/alias/ExampleAlias |
| 74 |
// Alias ARN: awskms:///arn:aws:kms:us-east-2:111122223333:alias/ExampleAlias |
| 75 |
// Alias ARN with endpoint: awskms://localhost:4566/arn:aws:kms:us-east-2:111122223333:alias/ExampleAlias |
| 76 |
uuidRE = `m?r?k?-?[A-Fa-f0-9]{8}-?[A-Fa-f0-9]{4}-?[A-Fa-f0-9]{4}-?[A-Fa-f0-9]{4}-?[A-Fa-f0-9]{12}` |
| 77 |
arnRE = `arn:(?:aws|aws-us-gov|aws-cn):kms:[a-z0-9-]+:\d{12}:` |
| 78 |
hostRE = `([^/]*)/` |
| 79 |
keyIDRE = regexp.MustCompile(`^awskms://` + hostRE + `(` + uuidRE + `)$`) |
| 80 |
keyARNRE = regexp.MustCompile(`^awskms://` + hostRE + `(` + arnRE + `key/` + uuidRE + `)$`) |
| 81 |
aliasNameRE = regexp.MustCompile(`^awskms://` + hostRE + `((alias/.*))$`) |
| 82 |
aliasARNRE = regexp.MustCompile(`^awskms://` + hostRE + `(` + arnRE + `(alias/.*))$`) |
| 83 |
allREs = []*regexp.Regexp{keyIDRE, keyARNRE, aliasNameRE, aliasARNRE} |
| 84 |
) |
| 85 |
|
| 86 |
// ValidReference returns a non-nil error if the reference string is invalid |
| 87 |
func ValidReference(ref string) error { |
| 88 |
for _, re := range allREs { |
| 89 |
if re.MatchString(ref) { |
| 90 |
return nil |
| 91 |
} |
| 92 |
} |
| 93 |
return errKMSReference |
| 94 |
} |
| 95 |
|
| 96 |
// ParseReference parses an awskms-scheme URI into its constituent parts. |
| 97 |
func ParseReference(resourceID string) (endpoint, keyID, alias string, err error) { |
| 98 |
var v []string |
| 99 |
for _, re := range allREs { |
| 100 |
v = re.FindStringSubmatch(resourceID) |
| 101 |
if len(v) >= 3 { |
| 102 |
endpoint, keyID = v[1], v[2] |
| 103 |
if len(v) == 4 { |
| 104 |
alias = v[3] |
| 105 |
} |
| 106 |
return |
| 107 |
} |
| 108 |
} |
| 109 |
err = fmt.Errorf("invalid awskms format %q", resourceID) |
| 110 |
return |
| 111 |
} |
| 112 |
|
| 113 |
func newAWSClient(ctx context.Context, keyResourceID string, opts ...func(*config.LoadOptions) error) (*awsClient, error) { |
| 114 |
if err := ValidReference(keyResourceID); err != nil { |
| 115 |
return nil, err |
| 116 |
} |
| 117 |
a := &awsClient{} |
| 118 |
var err error |
| 119 |
a.endpoint, a.keyID, a.alias, err = ParseReference(keyResourceID) |
| 120 |
if err != nil { |
| 121 |
return nil, err |
| 122 |
} |
| 123 |
|
| 124 |
if err := a.setupClient(ctx, opts...); err != nil { |
| 125 |
return nil, err |
| 126 |
} |
| 127 |
|
| 128 |
a.keyCache = ttlcache.New[string, cmk]( |
| 129 |
ttlcache.WithDisableTouchOnHit[string, cmk](), |
| 130 |
) |
| 131 |
|
| 132 |
return a, nil |
| 133 |
} |
| 134 |
|
| 135 |
func (a *awsClient) setupClient(ctx context.Context, opts ...func(*config.LoadOptions) error) (err error) { |
| 136 |
if os.Getenv("AWS_TLS_INSECURE_SKIP_VERIFY") == "1" { |
| 137 |
opts = append(opts, config.WithHTTPClient(&http.Client{ |
| 138 |
Transport: &http.Transport{ |
| 139 |
TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // nolint: gosec |
| 140 |
}, |
| 141 |
})) |
| 142 |
} |
| 143 |
|
| 144 |
cfg, err := config.LoadDefaultConfig(ctx, opts...) |
| 145 |
if err != nil { |
| 146 |
return fmt.Errorf("loading AWS config: %w", err) |
| 147 |
} |
| 148 |
if a.endpoint != "" { |
| 149 |
cfg.BaseEndpoint = aws.String("https://" + a.endpoint) |
| 150 |
} |
| 151 |
|
| 152 |
a.client = kms.NewFromConfig(cfg) |
| 153 |
return |
| 154 |
} |
| 155 |
|
| 156 |
type cmk struct { |
| 157 |
KeyMetadata *types.KeyMetadata |
| 158 |
PublicKey crypto.PublicKey |
| 159 |
} |
| 160 |
|
| 161 |
func (c *cmk) HashFunc() crypto.Hash { |
| 162 |
switch c.KeyMetadata.SigningAlgorithms[0] { |
| 163 |
case types.SigningAlgorithmSpecRsassaPssSha256, types.SigningAlgorithmSpecRsassaPkcs1V15Sha256, types.SigningAlgorithmSpecEcdsaSha256: |
| 164 |
return crypto.SHA256 |
| 165 |
case types.SigningAlgorithmSpecRsassaPssSha384, types.SigningAlgorithmSpecRsassaPkcs1V15Sha384, types.SigningAlgorithmSpecEcdsaSha384: |
| 166 |
return crypto.SHA384 |
| 167 |
case types.SigningAlgorithmSpecRsassaPssSha512, types.SigningAlgorithmSpecRsassaPkcs1V15Sha512, types.SigningAlgorithmSpecEcdsaSha512: |
| 168 |
return crypto.SHA512 |
| 169 |
default: |
| 170 |
return 0 |
| 171 |
} |
| 172 |
} |
| 173 |
|
| 174 |
func (c *cmk) Verifier() (signature.Verifier, error) { |
| 175 |
switch c.KeyMetadata.SigningAlgorithms[0] { |
| 176 |
case types.SigningAlgorithmSpecRsassaPssSha256, types.SigningAlgorithmSpecRsassaPssSha384, types.SigningAlgorithmSpecRsassaPssSha512: |
| 177 |
pub, ok := c.PublicKey.(*rsa.PublicKey) |
| 178 |
if !ok { |
| 179 |
return nil, fmt.Errorf("public key is not rsa") |
| 180 |
} |
| 181 |
return signature.LoadRSAPSSVerifier(pub, c.HashFunc(), nil) |
| 182 |
case types.SigningAlgorithmSpecRsassaPkcs1V15Sha256, types.SigningAlgorithmSpecRsassaPkcs1V15Sha384, types.SigningAlgorithmSpecRsassaPkcs1V15Sha512: |
| 183 |
pub, ok := c.PublicKey.(*rsa.PublicKey) |
| 184 |
if !ok { |
| 185 |
return nil, fmt.Errorf("public key is not rsa") |
| 186 |
} |
| 187 |
return signature.LoadRSAPKCS1v15Verifier(pub, c.HashFunc()) |
| 188 |
case types.SigningAlgorithmSpecEcdsaSha256, types.SigningAlgorithmSpecEcdsaSha384, types.SigningAlgorithmSpecEcdsaSha512: |
| 189 |
pub, ok := c.PublicKey.(*ecdsa.PublicKey) |
| 190 |
if !ok { |
| 191 |
return nil, fmt.Errorf("public key is not ecdsa") |
| 192 |
} |
| 193 |
return signature.LoadECDSAVerifier(pub, c.HashFunc()) |
| 194 |
default: |
| 195 |
return nil, fmt.Errorf("signing algorithm unsupported") |
| 196 |
} |
| 197 |
} |
| 198 |
|
| 199 |
func (a *awsClient) fetchCMK(ctx context.Context) (*cmk, error) { |
| 200 |
var err error |
| 201 |
cmk := &cmk{} |
| 202 |
cmk.PublicKey, err = a.fetchPublicKey(ctx) |
| 203 |
if err != nil { |
| 204 |
return nil, err |
| 205 |
} |
| 206 |
cmk.KeyMetadata, err = a.fetchKeyMetadata(ctx) |
| 207 |
if err != nil { |
| 208 |
return nil, err |
| 209 |
} |
| 210 |
return cmk, nil |
| 211 |
} |
| 212 |
|
| 213 |
func (a *awsClient) getHashFunc(ctx context.Context) (crypto.Hash, error) { |
| 214 |
cmk, err := a.getCMK(ctx) |
| 215 |
if err != nil { |
| 216 |
return 0, err |
| 217 |
} |
| 218 |
return cmk.HashFunc(), nil |
| 219 |
} |
| 220 |
|
| 221 |
func (a *awsClient) getCMK(ctx context.Context) (*cmk, error) { |
| 222 |
var lerr error |
| 223 |
loader := ttlcache.LoaderFunc[string, cmk]( |
| 224 |
func(c *ttlcache.Cache[string, cmk], _ string) *ttlcache.Item[string, cmk] { |
| 225 |
var k *cmk |
| 226 |
k, lerr = a.fetchCMK(ctx) |
| 227 |
if lerr == nil { |
| 228 |
return c.Set(cacheKey, *k, time.Second*300) |
| 229 |
} |
| 230 |
return nil |
| 231 |
}, |
| 232 |
) |
| 233 |
|
| 234 |
item := a.keyCache.Get(cacheKey, ttlcache.WithLoader[string, cmk](loader)) |
| 235 |
if lerr == nil { |
| 236 |
cmk := item.Value() |
| 237 |
return &cmk, nil |
| 238 |
} |
| 239 |
return nil, lerr |
| 240 |
} |
| 241 |
|
| 242 |
func (a *awsClient) createKey(ctx context.Context, algorithm string) (crypto.PublicKey, error) { |
| 243 |
if a.alias == "" { |
| 244 |
return nil, errors.New("must use alias key format") |
| 245 |
} |
| 246 |
|
| 247 |
// look for existing key first |
| 248 |
cmk, err := a.getCMK(ctx) |
| 249 |
if err == nil { |
| 250 |
out := cmk.PublicKey |
| 251 |
return out, nil |
| 252 |
} |
| 253 |
|
| 254 |
// return error if not *kms.NotFoundException |
| 255 |
var errNotFound *types.NotFoundException |
| 256 |
if !errors.As(err, &errNotFound) { |
| 257 |
return nil, fmt.Errorf("looking up key: %w", err) |
| 258 |
} |
| 259 |
|
| 260 |
usage := types.KeyUsageTypeSignVerify |
| 261 |
description := "Created by Sigstore" |
| 262 |
key, err := a.client.CreateKey(ctx, &kms.CreateKeyInput{ |
| 263 |
CustomerMasterKeySpec: types.CustomerMasterKeySpec(algorithm), |
| 264 |
KeyUsage: usage, |
| 265 |
Description: &description, |
| 266 |
}) |
| 267 |
if err != nil { |
| 268 |
return nil, fmt.Errorf("creating key: %w", err) |
| 269 |
} |
| 270 |
|
| 271 |
_, err = a.client.CreateAlias(ctx, &kms.CreateAliasInput{ |
| 272 |
AliasName: &a.alias, |
| 273 |
TargetKeyId: key.KeyMetadata.KeyId, |
| 274 |
}) |
| 275 |
if err != nil { |
| 276 |
return nil, fmt.Errorf("creating alias %q: %w", a.alias, err) |
| 277 |
} |
| 278 |
|
| 279 |
cmk, err = a.getCMK(ctx) |
| 280 |
if err != nil { |
| 281 |
return nil, fmt.Errorf("retrieving PublicKey from cache: %w", err) |
| 282 |
} |
| 283 |
|
| 284 |
return cmk.PublicKey, err |
| 285 |
} |
| 286 |
|
| 287 |
func (a *awsClient) verify(ctx context.Context, sig, message io.Reader, opts ...signature.VerifyOption) error { |
| 288 |
cmk, err := a.getCMK(ctx) |
| 289 |
if err != nil { |
| 290 |
return err |
| 291 |
} |
| 292 |
verifier, err := cmk.Verifier() |
| 293 |
if err != nil { |
| 294 |
return err |
| 295 |
} |
| 296 |
return verifier.VerifySignature(sig, message, opts...) |
| 297 |
} |
| 298 |
|
| 299 |
func (a *awsClient) verifyRemotely(ctx context.Context, sig, digest []byte) error { |
| 300 |
cmk, err := a.getCMK(ctx) |
| 301 |
if err != nil { |
| 302 |
return err |
| 303 |
} |
| 304 |
alg := cmk.KeyMetadata.SigningAlgorithms[0] |
| 305 |
messageType := types.MessageTypeDigest |
| 306 |
if _, err := a.client.Verify(ctx, &kms.VerifyInput{ |
| 307 |
KeyId: &a.keyID, |
| 308 |
Message: digest, |
| 309 |
MessageType: messageType, |
| 310 |
Signature: sig, |
| 311 |
SigningAlgorithm: alg, |
| 312 |
}); err != nil { |
| 313 |
return fmt.Errorf("unable to verify signature: %w", err) |
| 314 |
} |
| 315 |
return nil |
| 316 |
} |
| 317 |
|
| 318 |
func (a *awsClient) sign(ctx context.Context, digest []byte, _ crypto.Hash) ([]byte, error) { |
| 319 |
cmk, err := a.getCMK(ctx) |
| 320 |
if err != nil { |
| 321 |
return nil, err |
| 322 |
} |
| 323 |
alg := cmk.KeyMetadata.SigningAlgorithms[0] |
| 324 |
|
| 325 |
messageType := types.MessageTypeDigest |
| 326 |
out, err := a.client.Sign(ctx, &kms.SignInput{ |
| 327 |
KeyId: &a.keyID, |
| 328 |
Message: digest, |
| 329 |
MessageType: messageType, |
| 330 |
SigningAlgorithm: alg, |
| 331 |
}) |
| 332 |
if err != nil { |
| 333 |
return nil, fmt.Errorf("signing with kms: %w", err) |
| 334 |
} |
| 335 |
return out.Signature, nil |
| 336 |
} |
| 337 |
|
| 338 |
func (a *awsClient) fetchPublicKey(ctx context.Context) (crypto.PublicKey, error) { |
| 339 |
out, err := a.client.GetPublicKey(ctx, &kms.GetPublicKeyInput{ |
| 340 |
KeyId: &a.keyID, |
| 341 |
}) |
| 342 |
if err != nil { |
| 343 |
return nil, fmt.Errorf("getting public key: %w", err) |
| 344 |
} |
| 345 |
key, err := x509.ParsePKIXPublicKey(out.PublicKey) |
| 346 |
if err != nil { |
| 347 |
return nil, fmt.Errorf("parsing public key: %w", err) |
| 348 |
} |
| 349 |
return key, nil |
| 350 |
} |
| 351 |
|
| 352 |
func (a *awsClient) fetchKeyMetadata(ctx context.Context) (*types.KeyMetadata, error) { |
| 353 |
out, err := a.client.DescribeKey(ctx, &kms.DescribeKeyInput{ |
| 354 |
KeyId: &a.keyID, |
| 355 |
}) |
| 356 |
if err != nil { |
| 357 |
return nil, fmt.Errorf("getting key metadata: %w", err) |
| 358 |
} |
| 359 |
return out.KeyMetadata, nil |
| 360 |
} |