model

type BaseKeyProvider interface {
	ID() string
	Kind() types.ProviderKind
	VendOnDecrypt() bool
	DecryptDataKey(ctx context.Context, MKP MasterKeyProvider, encryptedDataKey EncryptedDataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
	DecryptDataKeyFromList(ctx context.Context, MKP MasterKeyProvider, encryptedDataKeys []EncryptedDataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
}

type CryptoMaterialsManager interface {
	GetEncryptionMaterials(ctx context.Context, request EncryptionMaterialsRequest) (EncryptionMaterial, error)
	DecryptMaterials(ctx context.Context, request DecryptionMaterialsRequest) (DecryptionMaterial, error)
	GetInstance() CryptoMaterialsManager // TODO research and test
}

type DataKey struct {
	// contains filtered or unexported fields
}

type DataKeyI interface {
	Key

	EncryptedDataKey() []byte
	DataKey() []byte
}

type DecryptionHandler interface {
	Decrypt(ctx context.Context, ciphertext []byte) ([]byte, format.MessageHeader, error)
}

type DecryptionMaterial interface {
	DataKey() DataKeyI
	VerificationKey() []byte
}

type DecryptionMaterials struct {
	// contains filtered or unexported fields
}

type DecryptionMaterialsRequest struct {
	Algorithm         *suite.AlgorithmSuite
	EncryptedDataKeys []EncryptedDataKeyI
	EncryptionContext suite.EncryptionContext
}

type EncryptedDataKey struct {
	// contains filtered or unexported fields
}

type EncryptedDataKeyI interface {
	Key
	EncryptedDataKey() []byte
}

type EncryptionBuffer interface {
	io.ReadWriter
	Bytes() []byte
	Len() int
	Reset()
}

type EncryptionHandler interface {
	Encrypt(ctx context.Context, source []byte, ec suite.EncryptionContext) ([]byte, format.MessageHeader, error)
}

type EncryptionMaterial interface {
	DataEncryptionKey() DataKeyI
	EncryptedDataKeys() []EncryptedDataKeyI
	EncryptionContext() suite.EncryptionContext
	SigningKey() *ecdsa.PrivateKey
}

type EncryptionMaterials struct {
	// contains filtered or unexported fields
}

type EncryptionMaterialsRequest struct {
	EncryptionContext suite.EncryptionContext
	Algorithm         *suite.AlgorithmSuite
	PlaintextLength   int
}

type KMSClient interface {
	GenerateDataKey(ctx context.Context, params *kms.GenerateDataKeyInput, optFns ...func(*kms.Options)) (*kms.GenerateDataKeyOutput, error)
	Encrypt(ctx context.Context, params *kms.EncryptInput, optFns ...func(*kms.Options)) (*kms.EncryptOutput, error)
	Decrypt(ctx context.Context, params *kms.DecryptInput, optFns ...func(*kms.Options)) (*kms.DecryptOutput, error)
}

type KMSClientFactory interface {
	NewFromConfig(cfg aws.Config, optFns ...func(options *kms.Options)) KMSClient
}

type Key interface {
	KeyBase
}

type KeyBase interface {
	KeyProvider() KeyMeta
	KeyID() string
}

type KeyMeta struct {
	ProviderID string
	KeyID      string
}

type MasterKey interface {
	MasterKeyBase
	GenerateDataKey(ctx context.Context, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
	EncryptDataKey(ctx context.Context, dataKey DataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (EncryptedDataKeyI, error)
	DecryptDataKey(ctx context.Context, encryptedDataKey EncryptedDataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
}

type MasterKeyBase interface {
	KeyID() string
	Metadata() KeyMeta
	OwnsDataKey(key Key) bool
}

type MasterKeyFactory interface {
	NewMasterKey(args ...interface{}) (MasterKey, error)
}

type MasterKeyProvider interface {
	ProviderBase

	AddMasterKey(keyID string) (MasterKey, error)
	NewMasterKey(ctx context.Context, keyID string) (MasterKey, error)
	MasterKeysForEncryption(ctx context.Context, ec suite.EncryptionContext) (MasterKey, []MasterKey, error)
	MasterKeyForDecrypt(ctx context.Context, metadata KeyMeta) (MasterKey, error)
	DecryptDataKey(ctx context.Context, encryptedDataKey EncryptedDataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
	DecryptDataKeyFromList(ctx context.Context, encryptedDataKeys []EncryptedDataKeyI, alg *suite.AlgorithmSuite, ec suite.EncryptionContext) (DataKeyI, error)
	ValidateMasterKey(keyID string) error
	MasterKeysForDecryption() []MasterKey
}

type ProviderBase interface {
	ProviderKind() types.ProviderKind
	ProviderID() string
	ValidateProviderID(otherID string) error
}

type Wrapper interface {
	SerializeEncryptedDataKey(encryptedKey, tag, iv []byte) []byte
	DeserializeEncryptedDataKey(b []byte, iVLen int) (encryptedData, iv []byte)
	SerializeKeyInfoPrefix(keyID string) []byte
}