diff --git a/bootstrapper/internal/initserver/initserver.go b/bootstrapper/internal/initserver/initserver.go index 3e68f1335..acef0b949 100644 --- a/bootstrapper/internal/initserver/initserver.go +++ b/bootstrapper/internal/initserver/initserver.go @@ -154,7 +154,7 @@ func (s *Server) setupDisk(masterSecret, salt []byte) error { } uuid = strings.ToLower(uuid) - diskKey, err := crypto.DeriveKey(masterSecret, salt, []byte(crypto.HKDFInfoPrefix+uuid), 32) + diskKey, err := crypto.DeriveKey(masterSecret, salt, []byte(crypto.HKDFInfoPrefix+uuid), crypto.DerivedKeyLengthDefault) if err != nil { return err } diff --git a/bootstrapper/internal/initserver/initserver_test.go b/bootstrapper/internal/initserver/initserver_test.go index fd89a9c99..879a87ec8 100644 --- a/bootstrapper/internal/initserver/initserver_test.go +++ b/bootstrapper/internal/initserver/initserver_test.go @@ -4,12 +4,14 @@ import ( "context" "errors" "net" + "strings" "sync" "testing" "time" "github.com/edgelesssys/constellation/bootstrapper/initproto" "github.com/edgelesssys/constellation/bootstrapper/internal/kubernetes/k8sapi/resources" + "github.com/edgelesssys/constellation/internal/crypto/testvector" "github.com/edgelesssys/constellation/internal/file" "github.com/edgelesssys/constellation/internal/logger" "github.com/spf13/afero" @@ -187,6 +189,68 @@ func TestSSHProtoKeysToMap(t *testing.T) { } } +func TestSetupDisk(t *testing.T) { + testCases := map[string]struct { + uuid string + masterSecret []byte + salt []byte + wantKey []byte + }{ + "lower case uuid": { + uuid: strings.ToLower(testvector.HKDF0xFF.Info), + masterSecret: testvector.HKDF0xFF.Secret, + salt: testvector.HKDF0xFF.Salt, + wantKey: testvector.HKDF0xFF.Output, + }, + "upper case uuid": { + uuid: strings.ToUpper(testvector.HKDF0xFF.Info), + masterSecret: testvector.HKDF0xFF.Secret, + salt: testvector.HKDF0xFF.Salt, + wantKey: testvector.HKDF0xFF.Output, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + assert := assert.New(t) + + disk := &fakeDisk{ + uuid: tc.uuid, + wantKey: tc.wantKey, + } + server := &Server{ + disk: disk, + } + + assert.NoError(server.setupDisk(tc.masterSecret, tc.salt)) + }) + } +} + +type fakeDisk struct { + uuid string + wantKey []byte +} + +func (d *fakeDisk) Open() error { + return nil +} + +func (d *fakeDisk) Close() error { + return nil +} + +func (d *fakeDisk) UUID() (string, error) { + return d.uuid, nil +} + +func (d *fakeDisk) UpdatePassphrase(passphrase string) error { + if passphrase != string(d.wantKey) { + return errors.New("wrong passphrase") + } + return nil +} + type stubDisk struct { openErr error closeErr error diff --git a/cli/internal/cmd/recover_test.go b/cli/internal/cmd/recover_test.go index df3b87e40..93273d322 100644 --- a/cli/internal/cmd/recover_test.go +++ b/cli/internal/cmd/recover_test.go @@ -3,9 +3,11 @@ package cmd import ( "bytes" "errors" + "strings" "testing" "github.com/edgelesssys/constellation/internal/constants" + "github.com/edgelesssys/constellation/internal/crypto/testvector" "github.com/edgelesssys/constellation/internal/file" "github.com/edgelesssys/constellation/internal/state" "github.com/spf13/afero" @@ -42,98 +44,77 @@ func TestRecover(t *testing.T) { validState := state.ConstellationState{CloudProvider: "GCP"} invalidCSPState := state.ConstellationState{CloudProvider: "invalid"} - writeMasterSecret := func(require *require.Assertions) afero.Fs { - fs := afero.NewMemMapFs() - handler := file.NewHandler(fs) - require.NoError(handler.WriteJSON("constellation-mastersecret.json", masterSecret{Key: []byte("master-secret"), Salt: []byte("salt")}, file.OptNone)) - return fs - } - testCases := map[string]struct { - setupFs func(*require.Assertions) afero.Fs existingState state.ConstellationState client *stubRecoveryClient + masterSecret testvector.HKDF endpointFlag string diskUUIDFlag string masterSecretFlag string configFlag string stateless bool wantErr bool - wantKey []byte }{ "works": { - setupFs: writeMasterSecret, existingState: validState, client: &stubRecoveryClient{}, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", - wantKey: []byte{ - 0xcb, 0x31, 0x9d, 0x3d, 0xe0, 0xb7, 0x8a, 0xe9, 0x20, 0xc0, 0x62, 0x00, 0x8f, 0xe4, 0x58, 0xa1, - 0x87, 0x85, 0x5d, 0xa0, 0xca, 0xe2, 0x04, 0x5c, 0x80, 0xe8, 0xe6, 0xd5, 0x8a, 0x6c, 0xcb, 0x49, - }, + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, }, "uppercase disk uuid works": { - setupFs: writeMasterSecret, existingState: validState, client: &stubRecoveryClient{}, endpointFlag: "192.0.2.1", - diskUUIDFlag: "ABCDEFAB-CDEF-ABCD-ABCD-ABCDEFABCDEF", - wantKey: []byte{ - 0x9b, 0xb8, 0x4a, 0x62, 0x01, 0xb3, 0x32, 0xf6, 0xf2, 0x79, 0x43, 0x09, 0x86, 0xe7, 0x25, 0x0e, - 0xd2, 0x77, 0xcb, 0x14, 0xe8, 0x8f, 0x38, 0xab, 0xe7, 0xd6, 0x25, 0x14, 0xa5, 0xa1, 0xff, 0xda, - }, + diskUUIDFlag: strings.ToUpper(testvector.HKDF0xFF.Info), + masterSecret: testvector.HKDF0xFF, }, "lowercase disk uuid results in same key": { - setupFs: writeMasterSecret, existingState: validState, client: &stubRecoveryClient{}, endpointFlag: "192.0.2.1", - diskUUIDFlag: "abcdefab-cdef-abcd-abcd-abcdefabcdef", - wantKey: []byte{ - 0x9b, 0xb8, 0x4a, 0x62, 0x01, 0xb3, 0x32, 0xf6, 0xf2, 0x79, 0x43, 0x09, 0x86, 0xe7, 0x25, 0x0e, - 0xd2, 0x77, 0xcb, 0x14, 0xe8, 0x8f, 0x38, 0xab, 0xe7, 0xd6, 0x25, 0x14, 0xa5, 0xa1, 0xff, 0xda, - }, + diskUUIDFlag: strings.ToLower(testvector.HKDF0xFF.Info), + masterSecret: testvector.HKDF0xFF, }, "missing flags": { - setupFs: func(require *require.Assertions) afero.Fs { return afero.NewMemMapFs() }, wantErr: true, }, "missing config": { - setupFs: writeMasterSecret, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, configFlag: "nonexistent-config", wantErr: true, }, "missing state": { - setupFs: writeMasterSecret, existingState: validState, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, stateless: true, wantErr: true, }, "invalid cloud provider": { - setupFs: writeMasterSecret, existingState: invalidCSPState, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, wantErr: true, }, "connect fails": { - setupFs: writeMasterSecret, existingState: validState, client: &stubRecoveryClient{connectErr: errors.New("connect failed")}, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, wantErr: true, }, "pushing state key fails": { - setupFs: writeMasterSecret, existingState: validState, client: &stubRecoveryClient{pushStateDiskKeyErr: errors.New("pushing key failed")}, endpointFlag: "192.0.2.1", - diskUUIDFlag: "00000000-0000-0000-0000-000000000000", + diskUUIDFlag: testvector.HKDFZero.Info, + masterSecret: testvector.HKDFZero, wantErr: true, }, } @@ -160,7 +141,10 @@ func TestRecover(t *testing.T) { if tc.configFlag != "" { require.NoError(cmd.Flags().Set("config", tc.configFlag)) } - fileHandler := file.NewHandler(tc.setupFs(require)) + + fs := afero.NewMemMapFs() + fileHandler := file.NewHandler(fs) + require.NoError(fileHandler.WriteJSON("constellation-mastersecret.json", masterSecret{Key: tc.masterSecret.Secret, Salt: tc.masterSecret.Salt}, file.OptNone)) if !tc.stateless { require.NoError(fileHandler.WriteJSON(constants.StateFilename, tc.existingState, file.OptNone)) } @@ -174,7 +158,7 @@ func TestRecover(t *testing.T) { assert.NoError(err) assert.Contains(out.String(), "Pushed recovery key.") - assert.Equal(tc.wantKey, tc.client.pushStateDiskKeyKey) + assert.Equal(tc.masterSecret.Output, tc.client.pushStateDiskKeyKey) }) } } @@ -245,40 +229,13 @@ func TestParseRecoverFlags(t *testing.T) { func TestDeriveStateDiskKey(t *testing.T) { testCases := map[string]struct { - masterKey []byte - salt []byte - diskUUID string - wantStateDiskKey []byte + masterSecret testvector.HKDF }{ "all zero": { - masterKey: []byte{ - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - }, - salt: []byte{ - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - }, - diskUUID: "00000000-0000-0000-0000-000000000000", - wantStateDiskKey: []byte{ - 0x2b, 0x5c, 0x82, 0x9f, 0x69, 0x1b, 0xfd, 0x42, 0x32, 0xf8, 0xaa, 0xc4, 0x64, 0xbc, 0xcc, 0x07, - 0xe6, 0x05, 0xc7, 0xc8, 0xe8, 0x2c, 0xbc, 0xa0, 0x98, 0x37, 0xe8, 0x6d, 0x0b, 0x6d, 0x06, 0x65, - }, + masterSecret: testvector.HKDFZero, }, "all 0xff": { - masterKey: []byte{ - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - }, - salt: []byte{ - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - }, - diskUUID: "ffffffff-ffff-ffff-ffff-ffffffffffff", - wantStateDiskKey: []byte{ - 0x14, 0x84, 0xaa, 0x39, 0xd3, 0x41, 0x5e, 0x90, 0x6e, 0x07, 0x94, 0x0f, 0xf2, 0x15, 0xd8, 0xb1, - 0xee, 0xe7, 0x05, 0xd3, 0x02, 0x7d, 0xba, 0x93, 0x30, 0x6a, 0xf4, 0xab, 0xff, 0x4f, 0x70, 0xbe, - }, + masterSecret: testvector.HKDF0xFF, }, } @@ -286,10 +243,10 @@ func TestDeriveStateDiskKey(t *testing.T) { t.Run(name, func(t *testing.T) { assert := assert.New(t) - stateDiskKey, err := deriveStateDiskKey(tc.masterKey, tc.salt, tc.diskUUID) + stateDiskKey, err := deriveStateDiskKey(tc.masterSecret.Secret, tc.masterSecret.Salt, tc.masterSecret.Info) assert.NoError(err) - assert.Equal(tc.wantStateDiskKey, stateDiskKey) + assert.Equal(tc.masterSecret.Output, stateDiskKey) }) } } diff --git a/internal/attestation/attestation_test.go b/internal/attestation/attestation_test.go new file mode 100644 index 000000000..f7d673667 --- /dev/null +++ b/internal/attestation/attestation_test.go @@ -0,0 +1,45 @@ +package attestation + +import ( + "testing" + + "github.com/edgelesssys/constellation/internal/crypto/testvector" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestDeriveClusterID(t *testing.T) { + require := require.New(t) + assert := assert.New(t) + + testvector := testvector.HKDFClusterID + clusterID, err := DeriveClusterID(testvector.Secret, testvector.Salt) + require.NoError(err) + assert.Equal(testvector.Output, clusterID) + + clusterIDdiff, err := DeriveClusterID(testvector.Secret, []byte("different-salt")) + require.NoError(err) + assert.NotEqual(clusterID, clusterIDdiff) + + clusterIDdiff, err = DeriveClusterID([]byte("different-secret"), testvector.Salt) + require.NoError(err) + assert.NotEqual(clusterID, clusterIDdiff) +} + +func TestDeriveMeasurementSecret(t *testing.T) { + require := require.New(t) + assert := assert.New(t) + + testvector := testvector.HKDFMeasurementSecret + measurementSecret, err := DeriveMeasurementSecret(testvector.Secret, testvector.Salt) + require.NoError(err) + assert.Equal(testvector.Output, measurementSecret) + + measurementSecretdiff, err := DeriveMeasurementSecret(testvector.Secret, []byte("different-salt")) + require.NoError(err) + assert.NotEqual(measurementSecret, measurementSecretdiff) + + measurementSecretdiff, err = DeriveMeasurementSecret([]byte("different-secret"), testvector.Salt) + require.NoError(err) + assert.NotEqual(measurementSecret, measurementSecretdiff) +} diff --git a/internal/crypto/crypto_test.go b/internal/crypto/crypto_test.go index 423d4963c..4f4c5a846 100644 --- a/internal/crypto/crypto_test.go +++ b/internal/crypto/crypto_test.go @@ -3,6 +3,7 @@ package crypto import ( "testing" + "github.com/edgelesssys/constellation/internal/crypto/testvector" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/goleak" @@ -28,6 +29,59 @@ func TestDeriveKey(t *testing.T) { key3, err := DeriveKey([]byte("secret"), []byte("salt"), []byte("second"), 32) require.NoError(err) assert.NotEqual(key1, key3) + + zeroInput := testvector.HKDFZero + out, err := DeriveKey(zeroInput.Secret, zeroInput.Salt, []byte(zeroInput.InfoPrefix+zeroInput.Info), zeroInput.Length) + require.NoError(err) + assert.Equal(zeroInput.Output, out) + + fInput := testvector.HKDF0xFF + out, err = DeriveKey(fInput.Secret, fInput.Salt, []byte(fInput.InfoPrefix+fInput.Info), fInput.Length) + require.NoError(err) + assert.Equal(fInput.Output, out) +} + +func TestVectorsHKDF(t *testing.T) { + testCases := map[string]struct { + secret []byte + salt []byte + info []byte + length uint + wantKey []byte + }{ + "rfc Test Case 1": { + secret: testvector.HKDFrfc1.Secret, + salt: testvector.HKDFrfc1.Salt, + info: []byte(testvector.HKDFrfc1.Info), + length: testvector.HKDFrfc1.Length, + wantKey: testvector.HKDFrfc1.Output, + }, + "rfc Test Case 2": { + secret: testvector.HKDFrfc2.Secret, + salt: testvector.HKDFrfc2.Salt, + info: []byte(testvector.HKDFrfc2.Info), + length: testvector.HKDFrfc2.Length, + wantKey: testvector.HKDFrfc2.Output, + }, + "rfc Test Case 3": { + secret: testvector.HKDFrfc3.Secret, + salt: testvector.HKDFrfc3.Salt, + info: []byte(testvector.HKDFrfc3.Info), + length: testvector.HKDFrfc3.Length, + wantKey: testvector.HKDFrfc3.Output, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + assert := assert.New(t) + require := require.New(t) + + out, err := DeriveKey(tc.secret, tc.salt, tc.info, tc.length) + require.NoError(err) + assert.Equal(tc.wantKey, out) + }) + } } func TestGenerateCertificateSerialNumber(t *testing.T) { diff --git a/internal/crypto/testvector/testvector.go b/internal/crypto/testvector/testvector.go new file mode 100644 index 000000000..aa9ccce71 --- /dev/null +++ b/internal/crypto/testvector/testvector.go @@ -0,0 +1,157 @@ +// Package testvector provides test vectors for key derivation and crypto functions. +package testvector + +// HKDF holds test vectors for the HKDF function. +type HKDF struct { + Secret []byte + Salt []byte + Info string + InfoPrefix string + Length uint + Output []byte +} + +// HKDFrfc1 is a test vector provided by the HKDF RFC. +// See: https://datatracker.ietf.org/doc/html/rfc5869#appendix-A.1 +var HKDFrfc1 = HKDF{ + Secret: []byte{ + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + }, + Salt: []byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + }, + Info: string([]byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9}), + Length: 42, + Output: []byte{ + 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43, 0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a, + 0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c, 0x5d, 0xb0, 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf, + 0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18, 0x58, 0x65, + }, +} + +// HKDFrfc2 is a test vector provided by the HKDF RFC. +// See: https://datatracker.ietf.org/doc/html/rfc5869#appendix-A.2 +var HKDFrfc2 = HKDF{ + Secret: []byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + }, + Salt: []byte{ + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + }, + Info: string([]byte{ + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, + }), + Length: 82, + Output: []byte{ + 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7, 0xf7, 0x8c, 0x59, 0x6a, 0x49, 0x34, + 0x4f, 0x01, 0x2e, 0xda, 0x2d, 0x4e, 0xfa, 0xd8, 0xa0, 0x50, 0xcc, 0x4c, 0x19, 0xaf, 0xa9, 0x7c, + 0x59, 0x04, 0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72, 0x71, 0xcb, 0x41, 0xc6, 0x5e, 0x59, 0x0e, 0x09, + 0xda, 0x32, 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8, 0x36, 0x77, 0x93, 0xa9, 0xac, 0xa3, 0xdb, 0x71, + 0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec, 0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5, 0xc1, 0xf3, 0x43, 0x4f, + 0x1d, 0x87, + }, +} + +// HKDFrfc3 is a test vector provided by the HKDF RFC. +// See: https://datatracker.ietf.org/doc/html/rfc5869#appendix-A.3 +var HKDFrfc3 = HKDF{ + Secret: []byte{ + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + }, + Length: 42, + Output: []byte{ + 0x8d, 0xa4, 0xe7, 0x75, 0xa5, 0x63, 0xc1, 0x8f, 0x71, 0x5f, 0x80, 0x2a, 0x06, 0x3c, 0x5a, 0x31, + 0xb8, 0xa1, 0x1f, 0x5c, 0x5e, 0xe1, 0x87, 0x9e, 0xc3, 0x45, 0x4e, 0x5f, 0x3c, 0x73, 0x8d, 0x2d, + 0x9d, 0x20, 0x13, 0x95, 0xfa, 0xa4, 0xb6, 0x1a, 0x96, 0xc8, + }, +} + +// HKDFZero is a test vector with zero values for HKDF key derivation. +var HKDFZero = HKDF{ + Secret: []byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }, + Salt: []byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }, + Info: "00000000-0000-0000-0000-000000000000", + InfoPrefix: "key-", + Length: 32, + Output: []byte{ + 0x2b, 0x5c, 0x82, 0x9f, 0x69, 0x1b, 0xfd, 0x42, 0x32, 0xf8, 0xaa, 0xc4, 0x64, 0xbc, 0xcc, 0x07, + 0xe6, 0x05, 0xc7, 0xc8, 0xe8, 0x2c, 0xbc, 0xa0, 0x98, 0x37, 0xe8, 0x6d, 0x0b, 0x6d, 0x06, 0x65, + }, +} + +// HKDF0xFF is a test vector with 0xFF values for HKDF key derivation. +var HKDF0xFF = HKDF{ + Secret: []byte{ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }, + Salt: []byte{ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }, + Info: "ffffffff-ffff-ffff-ffff-ffffffffffff", + InfoPrefix: "key-", + Length: 32, + Output: []byte{ + 0x14, 0x84, 0xaa, 0x39, 0xd3, 0x41, 0x5e, 0x90, 0x6e, 0x07, 0x94, 0x0f, 0xf2, 0x15, 0xd8, 0xb1, + 0xee, 0xe7, 0x05, 0xd3, 0x02, 0x7d, 0xba, 0x93, 0x30, 0x6a, 0xf4, 0xab, 0xff, 0x4f, 0x70, 0xbe, + }, +} + +// HKDFClusterID is a test vector with "clusterID" as info for HKDF key derivation. +var HKDFClusterID = HKDF{ + Secret: []byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + }, + Salt: []byte{ + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + }, + Info: "clusterID", + InfoPrefix: "key-", + Length: 32, + Output: []byte{ + 0x12, 0x8c, 0x16, 0x43, 0x78, 0xfe, 0x87, 0x67, 0xf9, 0x98, 0xfb, 0xdf, 0xe4, 0xb4, 0xd6, 0x46, + 0x3e, 0xc5, 0xae, 0x1b, 0x66, 0x4e, 0xa5, 0x99, 0x9b, 0xc2, 0x74, 0x17, 0x60, 0x7a, 0xe9, 0xb6, + }, +} + +// HKDFMeasurementSecret is a test vector with "measurementSecret" as info for HKDF key derivation. +var HKDFMeasurementSecret = HKDF{ + Secret: []byte{ + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + }, + Salt: []byte{ + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + }, + Info: "measurementSecret", + InfoPrefix: "key-", + Length: 32, + Output: []byte{ + 0x47, 0x90, 0x57, 0x88, 0x91, 0xf3, 0xfe, 0x6c, 0xc2, 0x2c, 0xb6, 0x61, 0xec, 0xdc, 0x1b, 0x7e, + 0x33, 0x12, 0x1b, 0x12, 0x87, 0x54, 0x6a, 0x52, 0xba, 0x33, 0xa9, 0x13, 0x67, 0x19, 0xc2, 0x13, + }, +} diff --git a/kms/kms/cluster/cluster_test.go b/kms/kms/cluster/cluster_test.go index 051875800..67d903b32 100644 --- a/kms/kms/cluster/cluster_test.go +++ b/kms/kms/cluster/cluster_test.go @@ -2,9 +2,12 @@ package cluster import ( "context" + "strings" "testing" + "github.com/edgelesssys/constellation/internal/crypto/testvector" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/goleak" ) @@ -13,31 +16,94 @@ func TestMain(m *testing.M) { } func TestClusterKMS(t *testing.T) { + testVector := testvector.HKDF0xFF assert := assert.New(t) - kms := &ClusterKMS{} - masterKey := []byte("Constellation") + kms := New(testVector.Salt) key, err := kms.GetDEK(context.Background(), "", "key-1", 32) assert.Error(err) assert.Nil(key) - err = kms.CreateKEK(context.Background(), "", masterKey) + err = kms.CreateKEK(context.Background(), "", testVector.Secret) assert.NoError(err) - assert.Equal(masterKey, kms.masterKey) + assert.Equal(testVector.Secret, kms.masterKey) - key1, err := kms.GetDEK(context.Background(), "", "key-1", 32) + keyLower, err := kms.GetDEK( + context.Background(), + "", + strings.ToLower(testVector.InfoPrefix+testVector.Info), + int(testVector.Length), + ) assert.NoError(err) - assert.Len(key1, 32) + assert.Equal(testVector.Output, keyLower) - key2, err := kms.GetDEK(context.Background(), "", "key-1", 32) + // output of the KMS should be case sensitive + keyUpper, err := kms.GetDEK( + context.Background(), + "", + strings.ToUpper(testVector.InfoPrefix+testVector.Info), + int(testVector.Length), + ) assert.NoError(err) - assert.Equal(key1, key2) - - key3, err := kms.GetDEK(context.Background(), "", "key-2", 32) - assert.NoError(err) - assert.NotEqual(key1, key3) - - key, err = kms.GetDEK(context.Background(), "", "key", 64) - assert.NoError(err) - assert.Len(key, 64) + assert.NotEqual(key, keyUpper) +} + +func TestVectorsHKDF(t *testing.T) { + testCases := map[string]struct { + kek []byte + salt []byte + dekID string + dekSize uint + wantKey []byte + }{ + "rfc Test Case 1": { + kek: testvector.HKDFrfc1.Secret, + salt: testvector.HKDFrfc1.Salt, + dekID: testvector.HKDFrfc1.Info, + dekSize: testvector.HKDFrfc1.Length, + wantKey: testvector.HKDFrfc1.Output, + }, + "rfc Test Case 2": { + kek: testvector.HKDFrfc2.Secret, + salt: testvector.HKDFrfc2.Salt, + dekID: testvector.HKDFrfc2.Info, + dekSize: testvector.HKDFrfc2.Length, + wantKey: testvector.HKDFrfc2.Output, + }, + "rfc Test Case 3": { + kek: testvector.HKDFrfc3.Secret, + salt: testvector.HKDFrfc3.Salt, + dekID: testvector.HKDFrfc3.Info, + dekSize: testvector.HKDFrfc3.Length, + wantKey: testvector.HKDFrfc3.Output, + }, + "HKDF zero": { + kek: testvector.HKDFZero.Secret, + salt: testvector.HKDFZero.Salt, + dekID: testvector.HKDFZero.InfoPrefix + testvector.HKDFZero.Info, + dekSize: testvector.HKDFZero.Length, + wantKey: testvector.HKDFZero.Output, + }, + "HKDF 0xFF": { + kek: testvector.HKDF0xFF.Secret, + salt: testvector.HKDF0xFF.Salt, + dekID: testvector.HKDF0xFF.InfoPrefix + testvector.HKDF0xFF.Info, + dekSize: testvector.HKDF0xFF.Length, + wantKey: testvector.HKDF0xFF.Output, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + assert := assert.New(t) + require := require.New(t) + + kms := New(tc.salt) + require.NoError(kms.CreateKEK(context.Background(), "", tc.kek)) + + out, err := kms.GetDEK(context.Background(), "", tc.dekID, int(tc.dekSize)) + require.NoError(err) + assert.Equal(tc.wantKey, out) + }) + } }