Debian Codegraph @

pkg/signature/kms/aws/client.go

raw
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 }