encryption

type Algo ¶

type Algo int32

const (
	Algo_UnknownAlgo Algo = 0
	Algo_GCM         Algo = 1
)

func NewAlgo(at AlgoType) (Algo, error)

func (Algo) Descriptor() protoreflect.EnumDescriptor

func (x Algo) Enum() *Algo

func (Algo) EnumDescriptor() ([]byte, []int)

func (x Algo) Number() protoreflect.EnumNumber

func (x Algo) String() string

func (Algo) Type() protoreflect.EnumType

type AlgoFactory ¶

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

AlgoFactory manufactures instances of Algorithm by invoking the AlgorithmCreator for the required AlgoType

var DefaultAlgoFactory *AlgoFactory

func NewAlgorithmFactory(as []AlgorithmCreator) (*AlgoFactory, error)

func (f *AlgoFactory) AddAlgorithmCreator(c AlgorithmCreator) error

func (f *AlgoFactory) GetAlgorithm(t AlgoType) (Algorithm, error)

type AlgoType ¶

type AlgoType string

AlgoType identifies the encryption algorithm used

const (
	Unknown AlgoType = "Unknown"
	GCM     AlgoType = "GCM"
)

func ParseAlgo(a Algo) (AlgoType, error)

type Algorithm ¶

type Algorithm interface {
	CreateKey() ([]byte, error)
	GetType() AlgoType
	GetEncryptor() Encryptor
	GetDecryptor() Decryptor
}

Algorithm provides an Encryptor and Decryptor interface, that implement the specified AlgoType

type AlgorithmCreator ¶

type AlgorithmCreator interface {
	New() Algorithm
}

AlgorithmCreator can construct instances of a Algorithm

func NewGCMCreator() AlgorithmCreator

type AlgorithmFactory ¶

type AlgorithmFactory interface {
	AddAlgorithmCreator(a AlgorithmCreator) error
	GetAlgorithm(t AlgoType) (Algorithm, error)
}

AlgorithmFactory returns a Algorithm using the specified algorithm

type Decryptor ¶

type Decryptor interface {
	Decrypt(key []byte, ciphertext []byte) ([]byte, error)
}

Decryptor will attempt to decrypt the ciphertext using the specified key

type EncryptedObject ¶

type EncryptedObject struct {
	KeyToken []byte `protobuf:"bytes,1,opt,name=keyToken,proto3" json:"keyToken,omitempty"`
	A        Algo   `protobuf:"varint,2,opt,name=a,proto3,enum=Algo" json:"a,omitempty"`
	V        []byte `protobuf:"bytes,3,opt,name=v,proto3" json:"v,omitempty"`
	// contains filtered or unexported fields
}

func NewEncryptedObject(key []byte, message protoreflect.ProtoMessage, encryptor Encryptor) (*EncryptedObject, error)

func NewEncryptedObjectFromToken(keyToken []byte, message protoreflect.ProtoMessage, encryptor TokenKeyEncryptor) (*EncryptedObject, error)

func (*EncryptedObject) Descriptor() ([]byte, []int)

func (x *EncryptedObject) GetA() Algo

func (x *EncryptedObject) GetKeyToken() []byte

func (x *EncryptedObject) GetV() []byte

func (*EncryptedObject) ProtoMessage()

func (x *EncryptedObject) ProtoReflect() protoreflect.Message

func (x *EncryptedObject) Reset()

func (x *EncryptedObject) String() string

type EncryptedObjectParser ¶

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

func NewEncryptedObjectParser(decryptor TokenKeyDecryptor) (*EncryptedObjectParser, error)

func (cp *EncryptedObjectParser) Parse(e *EncryptedObject, message protoreflect.ProtoMessage) error

type Encryptor ¶

type Encryptor interface {
	Encrypt(key, plaintext []byte) ([]byte, AlgoType, error)
}

Encryptor will attempt to use the key to encrypt the plaintext, returning the AlgoType used as well as the ciphertext

type Keys ¶

type Keys struct {
	Keys map[string][]byte `` /* 149-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*Keys) Descriptor() ([]byte, []int)

func (x *Keys) GetKeys() map[string][]byte

func (*Keys) ProtoMessage()

func (x *Keys) ProtoReflect() protoreflect.Message

func (x *Keys) Reset()

func (x *Keys) String() string

type TokenKeyDecryptor ¶

type TokenKeyDecryptor interface {
	DecryptFromToken(token []byte, a AlgoType, ciphertext []byte) ([]byte, error)
}

TokenKeyDecryptor receives a token value and AlgoType, which is used to retrieve the key required to decrypt and the algo to use to attempt decryption. Behaviour when the key is not available is unspecified.

type TokenKeyDecryptorCreator ¶

type TokenKeyDecryptorCreator func(a Algorithm, keys map[string][]byte) TokenKeyDecryptor

TokenKeyDecryptorCreator returns an initialised TokenKeyDecryptor

type TokenKeyEncryptionCreator ¶

type TokenKeyEncryptionCreator interface {
	GetID() TokenKeyEncryptionCreatorID
	GetEncryptionAlgoType() AlgoType
	GetTokenKeyDecryptor(key []byte, keys *EncryptedObject, factory AlgorithmFactory) (TokenKeyDecryptor, error)
	GetTokenKeyEncryptor() (TokenKeyEncryptor, error)
}

TokenKeyEncryptionCreator can manufacture encryptors and decryptors

func NewTokenKeyEncryptionCreator(
	id TokenKeyEncryptionCreatorID,
	a AlgoType,
	d TokenKeyDecryptorCreator,
	e TokenKeyEncryptorCreator,
	f AlgorithmFactory) (TokenKeyEncryptionCreator, error)

type TokenKeyEncryptionCreatorID ¶

type TokenKeyEncryptionCreatorID string

TokenKeyEncryptionCreatorID identifies TokenKeyEncryptionCreators

type TokenKeyEncryptionCreatorIDList ¶

type TokenKeyEncryptionCreatorIDList []TokenKeyEncryptionCreatorID

TokenKeyEncryptionCreatorIDList is a slice of TokenKeyEncryptionCreatorID

func (tl TokenKeyEncryptionCreatorIDList) Len() int

func (tl TokenKeyEncryptionCreatorIDList) Less(i, j int) bool

func (tl TokenKeyEncryptionCreatorIDList) Swap(i, j int)

type TokenKeyEncryptionFactory ¶

type TokenKeyEncryptionFactory interface {
	GetTokenKeyEncryptionCreatorIDs() TokenKeyEncryptionCreatorIDList
	AddTokenKeyEncryptionCreator(c TokenKeyEncryptionCreator) error
	GetTokenKeyDecryptor(i TokenKeyEncryptionCreatorID, key []byte, keys *EncryptedObject, factory AlgorithmFactory) (TokenKeyDecryptor, error)
	GetTokenKeyEncryptor(i TokenKeyEncryptionCreatorID) (TokenKeyEncryptor, error)
}

TokenKeyEncryptionFactory returns the encryptor or decryptor for the specified TokenKeyEncryptionCreatorID

var DefaultTokenKeyEncryptionFactory TokenKeyEncryptionFactory

func NewTokenKeyEncryptionFactory(as []TokenKeyEncryptionCreator) (TokenKeyEncryptionFactory, error)

type TokenKeyEncryptor ¶

type TokenKeyEncryptor interface {
	EncryptFromToken(token []byte, plaintext []byte) ([]byte, AlgoType, error)
	GetKeys(key []byte, a Algorithm) (*EncryptedObject, error)
}

TokenKeyEncryptor receives a token value which is used to retrieve the key required to encrypt.

The GetKeys function uses the provided key to encrypt the map of tokens->keys inside an EncryptedObject, for secure distribution

type TokenKeyEncryptorCreator ¶

type TokenKeyEncryptorCreator func(a Algorithm) TokenKeyEncryptor

TokenKeyEncryptorCreator returns an initialised TokenKeyEncryptor