api: implement namer, generator, validator

Closes TNTP-4190

Author: patapenka-alexey

hasher/hasher_test.go

@@ -61,9 +61,9 @@ func TestSHA256Hasher(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		name string
-		in   []byte
-		out  string
+		name     string
+		in       []byte
+		expected string
 	}{
 		{"empty", []byte(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
 		{"abc", []byte("abc"), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
@@ -77,7 +77,7 @@ func TestSHA256Hasher(t *testing.T) {
 
 			result, _ := h.Hash(test.in)
 
-			assert.Equal(t, test.out, hex.EncodeToString(result))
+			assert.Equal(t, test.expected, hex.EncodeToString(result))
 		})
 	}
 }

marshaller/marshaller.go

@@ -17,24 +17,24 @@ var ErrUnmarshall = errors.New("failed to unmarshal")
 // implements one time for all objects.
 // Required for `integrity.Storage` to set marshalling format for any type object
 // and as recommendation for developers of `Storage` wrappers.
-type DefaultMarshaller interface {
+type DefaultMarshaller interface { //nolint:iface
 	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // Marshallable - custom object serialization, implements for each object.
 // Required for `integrity.Storage` type to set marshalling format to specific object
 // and as recommendation for developers of `Storage` wrappers.
-type Marshallable interface {
-	Marshal() ([]byte, error)
+type Marshallable interface { //nolint:iface
+	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // YAMLMarshaller struct represent realization.
 type YAMLMarshaller struct{}
 
 // NewYamlMarshaller creates new NewYamlMarshaller object.
-func NewYamlMarshaller() YAMLMarshaller {
+func NewYamlMarshaller() Marshallable {
 	return YAMLMarshaller{}
 }
 

namer/generatorvalidator.go

@@ -0,0 +1,145 @@
+package namer
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/tarantool/go-storage/crypto"
+	"github.com/tarantool/go-storage/hasher"
+	"github.com/tarantool/go-storage/kv"
+	"github.com/tarantool/go-storage/marshaller"
+)
+
+// Generator generates signer K/V pairs.
+// Implementation should use `generic` and will used for strong typing of the solution.
+type Generator[T any] interface {
+	Generate(name string, value T) ([]kv.KeyValue, error)
+}
+
+// Validator validates and build the object from K/V.
+type Validator[T any] interface {
+	Validate(pairs []kv.KeyValue) (T, error)
+}
+
+// DefaultGeneratorValidator represent default generator-validator.
+type DefaultGeneratorValidator[T any] struct {
+	Namer          Namer
+	Hasher         hasher.Hasher
+	SignerVerifier crypto.SignerVerifier
+	Marshaller     marshaller.Marshallable
+}
+
+// NewDefaultGeneratorValidator returns new object.
+func NewDefaultGeneratorValidator[T any](
+	namer Namer,
+	hasher hasher.Hasher,
+	signverifier crypto.SignerVerifier,
+	marshaller marshaller.Marshallable,
+) DefaultGeneratorValidator[T] {
+	return DefaultGeneratorValidator[T]{
+		Namer:          namer,
+		Hasher:         hasher,
+		SignerVerifier: signverifier,
+		Marshaller:     marshaller,
+	}
+}
+
+// Generate create KV pairs with value, hash and signature.
+func (gv DefaultGeneratorValidator[T]) Generate(name string, value T) ([]kv.KeyValue, error) {
+	if name == "" {
+		return []kv.KeyValue{}, ErrInvalidInput
+	}
+
+	var kvList []kv.KeyValue
+
+	blob, err := gv.Marshaller.Marshal(value)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal: %w", err)
+	}
+
+	hash, err := gv.Hasher.Hash(blob)
+	if err != nil {
+		return nil, fmt.Errorf("failed to hash: %w", err)
+	}
+
+	signature, err := gv.SignerVerifier.Sign(hash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign: %w", err)
+	}
+
+	names := gv.Namer.GenerateNames(name)
+	keys := gv.Namer.ParseNames(names)
+
+	for _, key := range keys {
+		switch key.Type {
+		case KeyTypeValue:
+			{
+				kvList = append(kvList, kv.KeyValue{
+					Key:         []byte(key.Name),
+					Value:       blob,
+					ModRevision: 1,
+				})
+			}
+		case KeyTypeHash:
+			{
+				kvList = append(kvList, kv.KeyValue{
+					Key:         []byte(key.Name),
+					Value:       hash,
+					ModRevision: 1,
+				})
+			}
+		case KeyTypeSignature:
+			{
+				kvList = append(kvList, kv.KeyValue{
+					Key:         []byte(key.Name),
+					Value:       signature,
+					ModRevision: 1,
+				})
+			}
+		}
+	}
+
+	return kvList, nil
+}
+
+// Validate checks hash match, verify signature, unmarshall object and return it.
+func (gv DefaultGeneratorValidator[T]) Validate(pairs []kv.KeyValue) (T, error) {
+	var value T
+
+	var blob []byte
+
+	var hash, signature []byte
+
+	for _, keyvalue := range pairs {
+		switch {
+		case strings.Contains(string(keyvalue.Key), hashName):
+			hash = keyvalue.Value
+		case strings.Contains(string(keyvalue.Key), sigName):
+			signature = keyvalue.Value
+		default:
+			blob = keyvalue.Value
+		}
+	}
+
+	if blob == nil || hash == nil || signature == nil {
+		return value, ErrInvalidKey
+	}
+
+	err := gv.SignerVerifier.Verify(hash, signature)
+	if err != nil {
+		return value, fmt.Errorf("signature verification failed: %w", err)
+	}
+
+	computedHash, err := gv.Hasher.Hash(blob)
+	if !bytes.Equal(computedHash, hash) || err != nil {
+		return value, ErrHashMismatch
+	}
+
+	err = gv.Marshaller.Unmarshal(blob, &value)
+	if err != nil {
+		return value, fmt.Errorf("failed to unmarshal: %w", err)
+	}
+
+	return value, nil
+}

namer/generatorvalidator_test.go

@@ -0,0 +1,95 @@
+package namer_test
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tarantool/go-storage/hasher"
+	"github.com/tarantool/go-storage/kv"
+	"github.com/tarantool/go-storage/marshaller"
+	"github.com/tarantool/go-storage/namer"
+
+	gscrypto "github.com/tarantool/go-storage/crypto"
+)
+
+func TestGeneratorValidator(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		prefix   string
+		name     string
+		expected []kv.KeyValue
+	}{
+		{
+			"/tt/config",
+			"all",
+			[]kv.KeyValue{
+				{
+					Key:         []byte("/tt/config/all"),
+					Value:       []byte("value"),
+					ModRevision: 1,
+				},
+				{
+					Key: []byte("/tt/config/hash/all"),
+					Value: []byte{
+						0x1E, 0x1F, 0x2C, 0x88, 0x1A, 0xE0, 0x60, 0x8E, 0xC7, 0x7E, 0xBF, 0x88, 0xA7, 0x5C, 0x66, 0xD3,
+						0x09, 0x91, 0x13, 0xA7, 0x34, 0x32, 0x38, 0xF2, 0xF7, 0xA0, 0xEB, 0xB9, 0x1A, 0x4E, 0xD3, 0x35,
+					},
+					ModRevision: 1,
+				},
+				{
+					Key: []byte("/tt/config/sig/all"),
+					Value: []byte{
+						0x2c, 0xd0, 0x10, 0x8d, 0x3b, 0x43, 0x3b, 0x8e, 0x60, 0x22, 0x09, 0x78, 0x86, 0xf2, 0xe1, 0xd1,
+						0xcd, 0xea, 0xa0, 0x9b, 0xd0, 0x92, 0xb1, 0xc5, 0x90, 0x3a, 0x85, 0xeb, 0xd2, 0xe8, 0x3f, 0x43,
+						0x6d, 0xe2, 0x08, 0x1d, 0xfb, 0xc6, 0xd9, 0x04, 0x6e, 0x2c, 0x11, 0xa7, 0x6f, 0xcb, 0x27, 0x66,
+						0x0e, 0x6b, 0xc8, 0xbb, 0xe1, 0x77, 0x33, 0xa3, 0x65, 0x49, 0xbf, 0xc7, 0x6e, 0x18, 0x0e, 0x4d,
+						0x0f, 0x20, 0x0b, 0x51, 0xf9, 0x50, 0xdf, 0x76, 0x2d, 0x22, 0x0e, 0xa2, 0x1c, 0xa5, 0xdf, 0x49,
+						0xbd, 0x2b, 0xbd, 0xc7, 0xa6, 0x99, 0x8d, 0x55, 0x3b, 0xf8, 0xf4, 0xa2, 0xbf, 0xda, 0xf8, 0xe9,
+						0xf7, 0x41, 0xa8, 0xc4, 0xa9, 0x34, 0xef, 0x0b, 0xa4, 0xb5, 0x96, 0x08, 0x60, 0x8c, 0xa1, 0xdb,
+						0x4e, 0xd0, 0x5a, 0xed, 0x78, 0x3f, 0x0f, 0x9e, 0x74, 0x09, 0xf9, 0x75, 0x07, 0xbb, 0x5b, 0xe8,
+						0xbe, 0x44, 0xbf, 0x07, 0xf7, 0x9f, 0x26, 0x12, 0xb2, 0x02, 0xbf, 0x96, 0xdf, 0x18, 0x35, 0x46,
+						0x67, 0x9f, 0x7b, 0xe8, 0xdc, 0xfe, 0x7f, 0xac, 0xad, 0x5b, 0x94, 0x63, 0x0f, 0x1b, 0x03, 0xe6,
+						0x3f, 0x80, 0xb8, 0x9a, 0x7f, 0x5a, 0x4e, 0x1c, 0x7b, 0x51, 0x9b, 0x76, 0x3b, 0x50, 0xcd, 0x22,
+						0x95, 0xca, 0xf0, 0x0a, 0xac, 0xf8, 0x61, 0xbb, 0x9f, 0xe6, 0x36, 0xe5, 0xde, 0x6c, 0xb8, 0xfb,
+						0x3e, 0xb7, 0x94, 0x53, 0x20, 0x1e, 0xbc, 0xfa, 0x0a, 0x6e, 0x29, 0xcd, 0x91, 0xe5, 0xf3, 0xa9,
+						0x1a, 0xb2, 0x87, 0x97, 0x6f, 0x93, 0x77, 0x48, 0x08, 0xe3, 0xf9, 0x9d, 0xd3, 0x44, 0x18, 0x82,
+						0x58, 0x66, 0xf7, 0x41, 0x64, 0x41, 0x1d, 0xae, 0xef, 0x30, 0x3e, 0x6e, 0xf9, 0xeb, 0x0d, 0xbe,
+						0xb8, 0x90, 0x76, 0x79, 0x36, 0x44, 0x60, 0x0d, 0xa2, 0x15, 0xcc, 0xc8, 0x28, 0x0f, 0x5d, 0x36,
+					},
+					ModRevision: 1,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			defnamer := namer.NewDefaultNamer(tt.prefix)
+
+			hasher := hasher.NewSHA256Hasher()
+
+			privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
+			require.NoError(t, err)
+
+			sv := gscrypto.NewRSAPSS(*privateKey, privateKey.PublicKey)
+
+			mr := marshaller.NewYamlMarshaller()
+
+			dgv := namer.NewDefaultGeneratorValidator[string](defnamer, hasher, &sv, mr)
+
+			resultKV, err := dgv.Generate(tt.name, "value")
+			require.NoError(t, err)
+
+			require.Len(t, tt.expected, len(resultKV))
+
+			for i := range resultKV {
+				require.Equal(t, tt.expected[i].Key, resultKV[i].Key)
+			}
+		})
+	}
+}

namer/namer.go

@@ -2,7 +2,8 @@
 package namer
 
 import (
-	"github.com/tarantool/go-storage/kv"
+	"errors"
+	"strings"
 )
 
 // KeyType represents key types.
@@ -17,6 +18,21 @@ const (
 	KeyTypeSignature
 )
 
+const (
+	hashName    = "hash"
+	sigName     = "sig"
+	namesNumber = 3
+)
+
+var (
+	// ErrInvalidKey is returned when missing key, hash or signature.
+	ErrInvalidKey = errors.New("missing key, hash or signature")
+	// ErrHashMismatch is returned when hash mismatch.
+	ErrHashMismatch = errors.New("hash mismatch")
+	// ErrInvalidInput is returned when input data is invalid.
+	ErrInvalidInput = errors.New("failed to generate: invalid input data")
+)
+
 // Key implements internal realization.
 type Key struct {
 	Name     string  // Object identificator.
@@ -30,13 +46,61 @@ type Namer interface {
 	ParseNames(names []string) []Key    // Convert names into keys.
 }
 
-// Generator generates signer K/V pairs.
-// Implementation should use `generic` and will used for strong typing of the solution.
-type Generator[T any] interface {
-	Generate(name string, value T) ([]kv.KeyValue, error)
+// DefaultNamer represents default namer.
+type DefaultNamer struct {
+	prefix string
+}
+
+// NewDefaultNamer returns new DefaultNamer object.
+func NewDefaultNamer(prefix string) *DefaultNamer {
+	return &DefaultNamer{
+		prefix: prefix,
+	}
+}
+
+// GenerateNames generates set of names from basic name.
+func (n *DefaultNamer) GenerateNames(name string) []string {
+	return []string{
+		n.prefix + "/" + name,
+		n.prefix + "/" + hashName + "/" + name,
+		n.prefix + "/" + sigName + "/" + name,
+	}
 }
 
-// Validator validates and build the object from K/V.
-type Validator[T any] interface {
-	Validate(pairs []kv.KeyValue) (T, error)
+// ParseNames returns set of Keys with different types.
+func (n *DefaultNamer) ParseNames(names []string) []Key {
+	keys := make([]Key, 0, namesNumber)
+
+	for _, name := range names {
+		var key Key
+
+		// Remove prefix.
+		result := strings.ReplaceAll(name, n.prefix, "")
+
+		parts := strings.Split(result, "/")
+
+		key.Name = name
+
+		switch parts[1] {
+		case "hash":
+			{
+				key.Property = ""
+				key.Type = KeyTypeHash
+			}
+		case "sig":
+			{
+				key.Property = ""
+				key.Type = KeyTypeSignature
+			}
+		default:
+			{
+				key.Property = ""
+				key.Type = KeyTypeValue
+			}
+		}
+
+		keys = append(keys, key)
+	}
+
+	return keys
 }