Debian Codegraph @

pkg/signature/kms/hashivault/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 hashivault
19
20 import (
21 "bytes"
22 "context"
23 "crypto"
24 "crypto/ecdsa"
25 "crypto/rand"
26 "fmt"
27 "os"
28 "testing"
29
30 "github.com/stretchr/testify/assert"
31 "github.com/stretchr/testify/require"
32 "github.com/stretchr/testify/suite"
33
34 "github.com/sigstore/sigstore/pkg/signature"
35 "github.com/sigstore/sigstore/pkg/signature/options"
36
37 vault "github.com/hashicorp/vault/api"
38 )
39
40 type VaultSuite struct {
41 suite.Suite
42 vaultclient *vault.Client
43 }
44
45 func (suite *VaultSuite) GetProvider(key string, opts ...signature.RPCOption) *SignerVerifier {
46 provider, err := LoadSignerVerifier(fmt.Sprintf("hashivault://%s", key), crypto.SHA256, opts...)
47 require.NoError(suite.T(), err)
48 require.NotNil(suite.T(), provider)
49 return provider
50 }
51
52 func (suite *VaultSuite) SetupSuite() {
53 var err error
54 suite.vaultclient, err = vault.NewClient(&vault.Config{
55 Address: os.Getenv("VAULT_ADDR"),
56 })
57 require.Nil(suite.T(), err)
58 require.NotNil(suite.T(), suite.vaultclient)
59
60 err = suite.vaultclient.Sys().Mount("transit", &vault.MountInput{
61 Type: "transit",
62 })
63 require.Nil(suite.T(), err)
64
65 err = suite.vaultclient.Sys().Mount("somerandompath", &vault.MountInput{
66 Type: "transit",
67 })
68 require.Nil(suite.T(), err)
69 }
70
71 func (suite *VaultSuite) TearDownSuite() {
72 var err error
73 if suite.vaultclient == nil {
74 suite.vaultclient, err = vault.NewClient(&vault.Config{
75 Address: os.Getenv("VAULT_ADDR"),
76 })
77 require.Nil(suite.T(), err)
78 require.NotNil(suite.T(), suite.vaultclient)
79 }
80
81 err = suite.vaultclient.Sys().Unmount("transit")
82 require.Nil(suite.T(), err)
83 err = suite.vaultclient.Sys().Unmount("somerandompath")
84 require.Nil(suite.T(), err)
85 }
86
87 func (suite *VaultSuite) TestProvider() {
88 suite.GetProvider("provider")
89 }
90
91 func (suite *VaultSuite) TestCreateKey() {
92 provider := suite.GetProvider("createkey")
93
94 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
95 assert.Nil(suite.T(), err)
96 assert.NotNil(suite.T(), key)
97 }
98
99 func (suite *VaultSuite) TestSign() {
100 provider := suite.GetProvider("testsign")
101
102 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
103 assert.Nil(suite.T(), err)
104 assert.NotNil(suite.T(), key)
105
106 data := []byte("mydata")
107 sig, err := provider.SignMessage(bytes.NewReader(data))
108 assert.Nil(suite.T(), err)
109 assert.NotNil(suite.T(), sig)
110
111 verifier, _ := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
112 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
113 assert.Nil(suite.T(), err)
114 }
115
116 func (suite *VaultSuite) TestSignOpts() {
117 addr := os.Getenv("VAULT_ADDR")
118 token := os.Getenv("VAULT_TOKEN")
119 os.Setenv("VAULT_ADDR", "")
120 os.Setenv("VAULT_TOKEN", "")
121 defer os.Setenv("VAULT_ADDR", addr)
122 defer os.Setenv("VAULT_TOKEN", token)
123 provider := suite.GetProvider("testsign",
124 options.WithRPCAuthOpts(options.RPCAuth{Address: addr, Token: token}))
125
126 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
127 assert.Nil(suite.T(), err)
128 assert.NotNil(suite.T(), key)
129
130 data := []byte("mydata")
131 sig, err := provider.SignMessage(bytes.NewReader(data))
132 assert.Nil(suite.T(), err)
133 assert.NotNil(suite.T(), sig)
134
135 verifier, _ := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
136 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
137 assert.Nil(suite.T(), err)
138 }
139
140 func (suite *VaultSuite) TestSignSpecificKeyVersion() {
141 provider := suite.GetProvider("testsignversion")
142
143 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
144 assert.Nil(suite.T(), err)
145 assert.NotNil(suite.T(), key)
146
147 // test without specifying any value (aka use default)
148 data := []byte("mydata")
149 sig, err := provider.SignMessage(bytes.NewReader(data))
150 assert.Nil(suite.T(), err)
151 assert.NotNil(suite.T(), sig)
152 verifier, _ := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
153 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
154 assert.Nil(suite.T(), err)
155
156 // test with specifying default value
157 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("0"))
158 assert.Nil(suite.T(), err)
159 assert.NotNil(suite.T(), sig)
160
161 // test with specifying explicit value
162 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("1"))
163 assert.Nil(suite.T(), err)
164 assert.NotNil(suite.T(), sig)
165
166 // test version that doesn't (yet) exist
167 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("2"))
168 assert.NotNil(suite.T(), err)
169 assert.Nil(suite.T(), sig)
170
171 // rotate key (now two valid versions)
172 client := suite.vaultclient.Logical()
173 _, err = client.Write("/transit/keys/testsignversion/rotate", nil)
174 assert.Nil(suite.T(), err)
175
176 // test default version again (implicitly)
177 sig, err = provider.SignMessage(bytes.NewReader(data))
178 assert.Nil(suite.T(), err)
179 assert.NotNil(suite.T(), sig)
180
181 // test default version again (explicitly)
182 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("0"))
183 assert.Nil(suite.T(), err)
184 assert.NotNil(suite.T(), sig)
185
186 // test explicit previous version (should still work as we haven't set min_encryption_version yet)
187 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("1"))
188 assert.Nil(suite.T(), err)
189 assert.NotNil(suite.T(), sig)
190
191 // test explicit new version
192 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("2"))
193 assert.Nil(suite.T(), err)
194 assert.NotNil(suite.T(), sig)
195
196 // test bad value
197 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("3"))
198 assert.NotNil(suite.T(), err)
199 assert.Nil(suite.T(), sig)
200
201 // change minimum to v2
202 _, err = client.Write("/transit/keys/testsignversion/config", map[string]interface{}{
203 "min_encryption_version": 2,
204 })
205 assert.Nil(suite.T(), err)
206
207 // test explicit previous version (should fail as min_encryption_version has been set)
208 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("1"))
209 assert.NotNil(suite.T(), err)
210 assert.Nil(suite.T(), sig)
211
212 provider2 := suite.GetProvider("testsignversion", options.WithKeyVersion("2"))
213 sig, err = provider2.SignMessage(bytes.NewReader(data))
214 assert.Nil(suite.T(), err)
215 assert.NotNil(suite.T(), sig)
216
217 // test explicit new version
218 sig, err = provider2.SignMessage(bytes.NewReader(data), options.WithKeyVersion("2"))
219 assert.Nil(suite.T(), err)
220 assert.NotNil(suite.T(), sig)
221 }
222
223 func (suite *VaultSuite) TestVerifySpecificKeyVersion() {
224 provider := suite.GetProvider("testverifyversion")
225
226 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
227 assert.Nil(suite.T(), err)
228 assert.NotNil(suite.T(), key)
229
230 // test using v1
231 data := []byte("mydata")
232 sig, err := provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("1"))
233 assert.Nil(suite.T(), err)
234 assert.NotNil(suite.T(), sig)
235
236 // test without specifying key value
237 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
238 assert.Nil(suite.T(), err)
239
240 // test with explicitly specifying default value
241 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("1"))
242 assert.Nil(suite.T(), err)
243
244 // test version that doesn't (yet) exist
245 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("2"))
246 assert.NotNil(suite.T(), err)
247
248 // rotate key (now two valid versions)
249 client := suite.vaultclient.Logical()
250 _, err = client.Write("/transit/keys/testverifyversion/rotate", nil)
251 assert.Nil(suite.T(), err)
252
253 // test default version again (implicitly)
254 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
255 assert.Nil(suite.T(), err)
256
257 // test invalid version (0 is fine for signing, but must be >= 1 for verification)
258 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("0"))
259 assert.NotNil(suite.T(), err)
260
261 // test explicit previous version (should still as we haven't set min_decryption_version yet)
262 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("1"))
263 assert.Nil(suite.T(), err)
264
265 // test explicit new version (should fail since it doesn't match the v1 key)
266 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("2"))
267 assert.NotNil(suite.T(), err)
268
269 // test bad value
270 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("3"))
271 assert.NotNil(suite.T(), err)
272
273 // change minimum to v2
274 _, err = client.Write("/transit/keys/testverifyversion/config", map[string]interface{}{
275 "min_decryption_version": 2,
276 })
277 assert.Nil(suite.T(), err)
278
279 // test explicit previous version (should fail as min_decryption_version has been set)
280 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithKeyVersion("1"))
281 assert.NotNil(suite.T(), err)
282 }
283
284 func (suite *VaultSuite) TestSignAndRecordKeyVersion() {
285 provider := suite.GetProvider("testrecordsignversion")
286
287 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
288 assert.Nil(suite.T(), err)
289 assert.NotNil(suite.T(), key)
290
291 // test for v1
292 data := []byte("mydata")
293 var versionUsed string
294 sig, err := provider.SignMessage(bytes.NewReader(data), options.ReturnKeyVersionUsed(&versionUsed))
295 assert.Nil(suite.T(), err)
296 assert.NotNil(suite.T(), sig)
297 assert.Contains(suite.T(), versionUsed, "vault:v1:")
298
299 // rotate
300 client := suite.vaultclient.Logical()
301 _, err = client.Write("/transit/keys/testrecordsignversion/rotate", nil)
302 assert.Nil(suite.T(), err)
303
304 sig, err = provider.SignMessage(bytes.NewReader(data), options.WithKeyVersion("2"), options.ReturnKeyVersionUsed(&versionUsed))
305 assert.Nil(suite.T(), err)
306 assert.NotNil(suite.T(), sig)
307 assert.Contains(suite.T(), versionUsed, "vault:v2:")
308 }
309
310 func (suite *VaultSuite) TestSignWithDifferentTransitSecretEnginePath() {
311 provider := suite.GetProvider("testsign")
312 os.Setenv("TRANSIT_SECRET_ENGINE_PATH", "somerandompath")
313 defer os.Setenv("TRANSIT_SECRET_ENGINE_PATH", "transit")
314
315 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
316 assert.Nil(suite.T(), err)
317 assert.NotNil(suite.T(), key)
318
319 data := []byte("mydata")
320 sig, err := provider.SignMessage(bytes.NewReader(data), options.WithContext(context.Background()))
321 assert.Nil(suite.T(), err)
322 assert.NotNil(suite.T(), sig)
323
324 verifier, err := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
325 assert.Nil(suite.T(), err)
326
327 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithContext(context.Background()))
328 assert.Nil(suite.T(), err)
329 }
330
331 func (suite *VaultSuite) TestInvalidPublicKey() {
332 var provider *SignerVerifier
333 var err error
334 assert.NotPanics(suite.T(), func() {
335 provider, _ = LoadSignerVerifier("hashivault://pki_int", crypto.SHA256)
336 _, err = provider.client.fetchPublicKey(context.Background())
337 })
338 assert.NotNil(suite.T(), err)
339 }
340
341 func (suite *VaultSuite) TestSignWithDifferentTransitSecretEnginePathOpts() {
342 provider := suite.GetProvider("testsign", options.WithRPCAuthOpts(options.RPCAuth{Path: "somerandompath"}))
343
344 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
345 assert.Nil(suite.T(), err)
346 assert.NotNil(suite.T(), key)
347
348 data := []byte("mydata")
349 sig, err := provider.SignMessage(bytes.NewReader(data), options.WithContext(context.Background()))
350 assert.Nil(suite.T(), err)
351 assert.NotNil(suite.T(), sig)
352
353 verifier, err := signature.LoadECDSAVerifier(key.(*ecdsa.PublicKey), crypto.SHA256)
354 assert.Nil(suite.T(), err)
355
356 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data), options.WithContext(context.Background()))
357 assert.Nil(suite.T(), err)
358 }
359
360 func (suite *VaultSuite) TestPubKeyVerify() {
361 provider := suite.GetProvider("testsign")
362
363 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
364 require.Nil(suite.T(), err)
365 require.NotNil(suite.T(), key)
366
367 data := []byte("mydata")
368 sig, err := provider.SignMessage(bytes.NewReader(data))
369 require.Nil(suite.T(), err)
370 require.NotNil(suite.T(), sig)
371
372 k, err := provider.PublicKey()
373 require.NotNil(suite.T(), k)
374 require.Nil(suite.T(), err)
375
376 pubKey, ok := k.(*ecdsa.PublicKey)
377 require.True(suite.T(), ok)
378
379 verifier, _ := signature.LoadECDSAVerifier(pubKey, crypto.SHA256)
380 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
381 assert.Nil(suite.T(), err)
382 }
383
384 func (suite *VaultSuite) TestCryptoSigner() {
385 provider := suite.GetProvider("testsign")
386
387 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
388 require.Nil(suite.T(), err)
389 require.NotNil(suite.T(), key)
390
391 data := []byte("mydata")
392 cs, opts, err := provider.CryptoSigner(context.Background(), func(err error) { require.Nil(suite.T(), err) })
393 hasher := opts.HashFunc().New()
394 _, _ = hasher.Write(data)
395 sig, err := cs.Sign(rand.Reader, hasher.Sum(nil), opts)
396 require.Nil(suite.T(), err)
397 require.NotNil(suite.T(), sig)
398
399 k := cs.Public()
400 require.NotNil(suite.T(), k)
401
402 pubKey, ok := k.(*ecdsa.PublicKey)
403 require.True(suite.T(), ok)
404
405 verifier, _ := signature.LoadECDSAVerifier(pubKey, crypto.SHA256)
406 err = verifier.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
407 assert.Nil(suite.T(), err)
408 }
409
410 func (suite *VaultSuite) TestVerify() {
411 provider := suite.GetProvider("testverify")
412
413 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
414 assert.Nil(suite.T(), err)
415 assert.NotNil(suite.T(), key)
416
417 data := []byte("mydata")
418 sig, err := provider.SignMessage(bytes.NewReader(data))
419 assert.Nil(suite.T(), err)
420 assert.NotNil(suite.T(), sig)
421
422 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
423 assert.Nil(suite.T(), err)
424 }
425
426 func (suite *VaultSuite) TestED25519() {
427 provider := suite.GetProvider("tested25519")
428
429 key, err := provider.CreateKey(context.Background(), AlgorithmED25519)
430 assert.Nil(suite.T(), err)
431 assert.NotNil(suite.T(), key)
432
433 data := []byte("mydata")
434 sig, err := provider.SignMessage(bytes.NewReader(data))
435 assert.Nil(suite.T(), err)
436 assert.NotNil(suite.T(), sig)
437
438 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(data))
439 assert.Nil(suite.T(), err)
440 }
441
442 func (suite *VaultSuite) TestVerifyBadData() {
443 provider := suite.GetProvider("testverify")
444
445 key, err := provider.CreateKey(context.Background(), AlgorithmECDSAP256)
446 assert.Nil(suite.T(), err)
447 assert.NotNil(suite.T(), key)
448
449 data := []byte("mydata")
450 sig, err := provider.SignMessage(bytes.NewReader(data))
451 assert.Nil(suite.T(), err)
452 assert.NotNil(suite.T(), sig)
453
454 dataInvalid := []byte("mydata-invalid")
455 err = provider.VerifySignature(bytes.NewReader(sig), bytes.NewReader(dataInvalid))
456 assert.Contains(suite.T(), err.Error(), "failed vault verification")
457 }
458
459 func (suite *VaultSuite) TestBadSignature() {
460 provider1 := suite.GetProvider("testverify1")
461 provider2 := suite.GetProvider("testverify2")
462
463 key1, err := provider1.CreateKey(context.Background(), AlgorithmECDSAP256)
464 assert.Nil(suite.T(), err)
465 assert.NotNil(suite.T(), key1)
466
467 key2, err := provider2.CreateKey(context.Background(), AlgorithmECDSAP256)
468 assert.Nil(suite.T(), err)
469 assert.NotNil(suite.T(), key2)
470
471 data := []byte("mydata")
472 sig1, err := provider1.SignMessage(bytes.NewReader(data))
473 assert.Nil(suite.T(), err)
474 assert.NotNil(suite.T(), sig1)
475
476 err = provider1.VerifySignature(bytes.NewReader(sig1), bytes.NewReader(data))
477 assert.Nil(suite.T(), err)
478
479 err = provider2.VerifySignature(bytes.NewReader(sig1), bytes.NewReader(data))
480 assert.NotNil(suite.T(), err)
481 assert.Contains(suite.T(), err.Error(), "failed vault verification")
482 }
483
484 func (suite *VaultSuite) TestNoProvider() {
485 provider, err := LoadSignerVerifier("hashi://nonsense", crypto.Hash(0))
486 require.Error(suite.T(), err)
487 require.Nil(suite.T(), provider)
488 }
489
490 func (suite *VaultSuite) TestInvalidHost() {
491 provider, err := LoadSignerVerifier("hashivault://keyname", crypto.SHA256,
492 options.WithRPCAuthOpts(options.RPCAuth{Address: "https://unknown.example.com:8200"}))
493 assert.Nil(suite.T(), err)
494 assert.NotNil(suite.T(), provider)
495
496 _, err = provider.CreateKey(context.Background(), AlgorithmECDSAP256)
497 require.Error(suite.T(), err)
498 }
499
500 func TestVault(t *testing.T) {
501 suite.Run(t, new(VaultSuite))
502 }