Debian Codegraph @

pkg/signature/kms/aws/e2e_test.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 //go:build e2e
17
18 package aws
19
20 import (
21 "bytes"
22 "context"
23 "crypto"
24 "crypto/ecdsa"
25 "fmt"
26 "os"
27 "testing"
28
29 "github.com/stretchr/testify/assert"
30 "github.com/stretchr/testify/require"
31 "github.com/stretchr/testify/suite"
32
33 "github.com/aws/aws-sdk-go-v2/aws"
34 "github.com/aws/aws-sdk-go-v2/aws/retry"
35 "github.com/aws/aws-sdk-go-v2/config"
36 awskms "github.com/aws/aws-sdk-go-v2/service/kms/types"
37 "github.com/sigstore/sigstore/pkg/signature"
38 "github.com/sigstore/sigstore/pkg/signature/options"
39 )
40
41 type AWSSuite struct {
42 suite.Suite
43 endpoint string
44 }
45
46 // Address intermittent failure in issue #1110
47 type Issue1110Error struct{}
48
49 func (i Issue1110Error) IsErrorRetryable(err error) aws.Ternary {
50 if err != nil && err.Error() == "use of closed network connection" {
51 return aws.BoolTernary(true)
52 }
53 return aws.UnknownTernary
54 }
55
56 func (suite *AWSSuite) GetProvider(key string) *SignerVerifier {
57 provider, err := LoadSignerVerifier(context.Background(), fmt.Sprintf("awskms://%s/%s", suite.endpoint, key),
58 config.WithRetryer(func() aws.Retryer {
59 return retry.NewStandard(func(opts *retry.StandardOptions) {
60 opts.Retryables = append(opts.Retryables, Issue1110Error{})
61 })
62 }))
63 require.NoError(suite.T(), err)
64 require.NotNil(suite.T(), provider)
65 return provider
66 }
67
68 func (suite *AWSSuite) SetupSuite() {
69 suite.endpoint = os.Getenv("AWS_ENDPOINT")
70 }
71
72 func (suite *AWSSuite) TestGetProvider() {
73 _ = suite.GetProvider("alias/provider")
74 _ = suite.GetProvider("1234abcd-12ab-34cd-56ef-1234567890ab")
75 }
76
77 func (suite *AWSSuite) TestInvalidProvider() {
78 provider, err := LoadSignerVerifier(context.Background(), fmt.Sprintf("awskms://%s/nonsense", suite.endpoint))
79 require.Error(suite.T(), err)
80 require.Nil(suite.T(), provider)
81 }
82
83 func (suite *AWSSuite) TestCreateKey() {
84 provider := suite.GetProvider("alias/provider")
85
86 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
87 require.Nil(suite.T(), err)
88 require.NotNil(suite.T(), key)
89
90 key2, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
91 require.Nil(suite.T(), err)
92 require.NotNil(suite.T(), key)
93
94 // Subsequent call should produce same key
95 assert.Equal(suite.T(), key, key2)
96 }
97
98 func (suite *AWSSuite) TestCreateKeyByID() {
99 provider := suite.GetProvider("1234abcd-12ab-34cd-56ef-1234567890ab")
100
101 // CreateKey can only work with aliases, not IDs
102 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
103 require.Error(suite.T(), err)
104 require.Nil(suite.T(), key)
105 }
106
107 func (suite *AWSSuite) TestSign() {
108 provider := suite.GetProvider("alias/TestSign")
109
110 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
111 require.Nil(suite.T(), err)
112 require.NotNil(suite.T(), key)
113
114 data := []byte("mydata")
115 sig, err := provider.SignMessage(bytes.NewReader(data))
116 require.Nil(suite.T(), err)
117 require.NotNil(suite.T(), sig)
118
119 verifier, _ := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
120 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
121 assert.Nil(suite.T(), err)
122 }
123
124 func (suite *AWSSuite) TestSHA384() {
125 provider := suite.GetProvider("alias/TestSHA384")
126
127 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP384))
128 require.Nil(suite.T(), err)
129 require.NotNil(suite.T(), key)
130
131 data := []byte("mydata")
132 sig, err := provider.SignMessage(bytes.NewReader(data))
133 require.Nil(suite.T(), err)
134 require.NotNil(suite.T(), sig)
135
136 k, err := provider.PublicKey()
137 require.Nil(suite.T(), err)
138 require.NotNil(suite.T(), key)
139
140 pubKey, ok := k.(*ecdsa.PublicKey)
141 require.True(suite.T(), ok, fmt.Sprintf("expected type ecdsa, got type %T", k))
142
143 verifier, _ := signature.LoadECDSAVerifier(pubKey, crypto.SHA384)
144 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
145 assert.Nil(suite.T(), err)
146 }
147
148 func (suite *AWSSuite) TestPublicKey() {
149 provider := suite.GetProvider("alias/TestPubKeyVerify")
150
151 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
152 require.Nil(suite.T(), err)
153 require.NotNil(suite.T(), key)
154
155 data := []byte("mydata")
156 sig, err := provider.SignMessage(bytes.NewReader(data))
157 require.NotNil(suite.T(), sig)
158 require.Nil(suite.T(), err)
159
160 k, err := provider.PublicKey()
161 require.Nil(suite.T(), err)
162 require.NotNil(suite.T(), key)
163
164 pubKey, ok := k.(*ecdsa.PublicKey)
165 require.True(suite.T(), ok, fmt.Sprintf("expected type ecdsa, got: %T", k))
166
167 verifier, _ := signature.LoadECDSAVerifier(pubKey, crypto.SHA256)
168 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
169 assert.Nil(suite.T(), err)
170 }
171
172 func (suite *AWSSuite) TestVerify() {
173 provider := suite.GetProvider("alias/TestVerify")
174
175 key, err := provider.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
176 require.Nil(suite.T(), err)
177 require.NotNil(suite.T(), key)
178
179 data := []byte("mydata")
180 sig, err := provider.SignMessage(bytes.NewReader(data))
181 require.Nil(suite.T(), err)
182 require.NotNil(suite.T(), sig)
183
184 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
185 assert.Nil(suite.T(), err)
186
187 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithRemoteVerification(true))
188 assert.Nil(suite.T(), err)
189 }
190
191 func (suite *AWSSuite) TestTwoProviders() {
192 provider1 := suite.GetProvider("alias/TestTwoProviders")
193 provider2 := suite.GetProvider("alias/TestTwoProviders")
194
195 key, err := provider1.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
196 require.Nil(suite.T(), err)
197 require.NotNil(suite.T(), key)
198
199 data := []byte("mydata")
200 sig, err := provider1.SignMessage(bytes.NewReader(data))
201 require.Nil(suite.T(), err)
202 require.NotNil(suite.T(), sig)
203
204 err = provider2.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
205 assert.Nil(suite.T(), err)
206 }
207
208 func (suite *AWSSuite) TestBadSignature() {
209 provider1 := suite.GetProvider("alias/TestBadSignature1")
210 provider2 := suite.GetProvider("alias/TestBadSignature2")
211
212 key1, err := provider1.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
213 require.Nil(suite.T(), err)
214 require.NotNil(suite.T(), key1)
215
216 key2, err := provider2.CreateKey(context.Background(), string(awskms.CustomerMasterKeySpecEccNistP256))
217 require.Nil(suite.T(), err)
218 require.NotNil(suite.T(), key2)
219
220 data := []byte("mydata")
221 sig, err := provider1.SignMessage(bytes.NewReader(data))
222 require.Nil(suite.T(), err)
223 require.NotNil(suite.T(), sig)
224
225 err = provider2.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
226 assert.Contains(suite.T(), err.Error(), "invalid signature when validating ASN.1 encoded signature")
227
228 err = provider2.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithRemoteVerification(true))
229 assert.Contains(suite.T(), err.Error(), "KMSInvalidSignatureException")
230 }
231
232 func (suite *AWSSuite) TestKeyTypes() {
233 for _, cmkSpec := range []string{
234 string(awskms.CustomerMasterKeySpecRsa2048),
235 string(awskms.CustomerMasterKeySpecRsa3072),
236 string(awskms.CustomerMasterKeySpecRsa4096),
237 string(awskms.CustomerMasterKeySpecEccNistP256),
238 string(awskms.CustomerMasterKeySpecEccNistP384),
239 string(awskms.CustomerMasterKeySpecEccNistP521),
240 // awskms.CustomerMasterKeySpecEccSecgP256k1, // unsupported by localstack at the moment
241 } {
242 suite.T().Run(fmt.Sprintf("KeyType-%s", cmkSpec), func(t *testing.T) {
243 provider := suite.GetProvider("alias/" + cmkSpec)
244 key, err := provider.CreateKey(context.Background(), cmkSpec)
245 require.Nil(suite.T(), err)
246 require.NotNil(suite.T(), key)
247
248 data := []byte("mydata")
249 sig, err := provider.SignMessage(bytes.NewReader(data))
250 require.Nil(suite.T(), err)
251 require.NotNil(suite.T(), sig)
252
253 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
254 assert.Nil(suite.T(), err)
255 })
256 }
257 }
258
259 func (suite *AWSSuite) TestCancelContext() {
260 ctx, cancel := context.WithCancel(context.Background())
261 cancel()
262
263 provider := suite.GetProvider("alias/TestCancelContext")
264 key, err := provider.CreateKey(ctx, string(awskms.CustomerMasterKeySpecEccNistP256))
265 assert.Error(suite.T(), err)
266 assert.Contains(suite.T(), err.Error(), context.Canceled.Error())
267 assert.Nil(suite.T(), key)
268
269 data := []byte("mydata")
270 sig, err := provider.SignMessage(bytes.NewReader(data), options.WithContext(ctx))
271 assert.Error(suite.T(), err)
272 assert.Contains(suite.T(), err.Error(), context.Canceled.Error())
273 assert.Nil(suite.T(), sig)
274
275 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithContext(ctx))
276 assert.Error(suite.T(), err)
277 assert.Contains(suite.T(), err.Error(), context.Canceled.Error())
278 }
279
280 func TestAWS(t *testing.T) {
281 suite.Run(t, new(AWSSuite))
282 }