cipher

Documentation

Overview

cipher package is a helper package for encrypting and decrypting messages

Index

• Constants
• func GeneratePrivateKey(size int) *rsa.PrivateKey
• func GetHash(hashType string) crypto.Hash
• func GetPrivateKey(loader KeyLoader) (*rsa.PrivateKey, error)
• func GetPublicKey(loader KeyLoader) (*rsa.PublicKey, error)
• func Sub(v *viper.Viper) *viper.Viper
• type BasicHashLoader
  • func (b *BasicHashLoader) GetHash() (crypto.Hash, error)
• type BasicLoader
  • func (loader *BasicLoader) LoadDecrypt() (Decrypt, error)
  • func (loader *BasicLoader) LoadEncrypt() (Encrypt, error)
• type BoxLoader
  • func (boxLoader *BoxLoader) LoadDecrypt() (Decrypt, error)
  • func (boxLoader *BoxLoader) LoadEncrypt() (Encrypt, error)
• type BytesLoader
  • func (b *BytesLoader) GetBytes() ([]byte, error)
• type Decrypt
  • func DefaultCipherDecrypter() Decrypt
  • func NewBasicDecrypter(hash crypto.Hash, recipientPrivateKey *rsa.PrivateKey, ...) Decrypt
  • func NewBoxDecrypter(recipientPrivateKey [32]byte, senderPublicKey [32]byte) Decrypt
• type DecryptLoader
• type Encrypt
  • func DefaultCipherEncrypter() Encrypt
  • func NewBasicEncrypter(hash crypto.Hash, senderPrivateKey *rsa.PrivateKey, ...) Encrypt
  • func NewBoxEncrypter(senderPrivateKey [32]byte, recipientPublicKey [32]byte) Encrypt
• type EncryptLoader
• type FileLoader
  • func (f *FileLoader) GetBytes() ([]byte, error)
• type HashLoader
• type KeyLoader
• type LocalCerts
• type NOOP
  • func (*NOOP) DecryptMessage(cipher []byte, nonce []byte) (message []byte, err error)
  • func (*NOOP) EncryptMessage(message []byte) (crypt []byte, nonce []byte, err error)
• type Options
  • func FromViper(v *viper.Viper) (*Options, error)
  • func (o *Options) LoadDecrypt() (Decrypt, error)
  • func (o *Options) LoadEncrypt() (Encrypt, error)

Constants

const (
	// CipherKey is the Viper subkey under which logging should be stored.
	// NewOptions *does not* assume this key.
	CipherKey = "cipher"
)

Functions

func GeneratePrivateKey

func GeneratePrivateKey(size int) *rsa.PrivateKey

GeneratePrivateKey will create a private key with the size given size must be greater than 64 or else it will default to 64.

Careful with the size, if its too large it won't encrypt the message or take forever

func GetHash

func GetHash(hashType string) crypto.Hash

func GetPrivateKey

func GetPrivateKey(loader KeyLoader) (*rsa.PrivateKey, error)

func GetPublicKey

func GetPublicKey(loader KeyLoader) (*rsa.PublicKey, error)

func Sub

func Sub(v *viper.Viper) *viper.Viper

Sub returns the standard child Viper, using CipherKey, for this package. If passed nil, this function returns nil.

Types

type BasicHashLoader

type BasicHashLoader struct {
	HashName string `mapstructure:"hash"`
}

func (*BasicHashLoader) GetHash

func (b *BasicHashLoader) GetHash() (crypto.Hash, error)

GetHash return the given hash from hashFunctions if not found it will return an error.

0 is an invalid hash

type BasicLoader

type BasicLoader struct {
	Hash       HashLoader
	PrivateKey KeyLoader
	PublicKey  KeyLoader
}

func (*BasicLoader) LoadDecrypt

func (loader *BasicLoader) LoadDecrypt() (Decrypt, error)

func (*BasicLoader) LoadEncrypt

func (loader *BasicLoader) LoadEncrypt() (Encrypt, error)

type BoxLoader

type BoxLoader struct {
	PrivateKey KeyLoader
	PublicKey  KeyLoader
}

func (*BoxLoader) LoadDecrypt

func (boxLoader *BoxLoader) LoadDecrypt() (Decrypt, error)

func (*BoxLoader) LoadEncrypt

func (boxLoader *BoxLoader) LoadEncrypt() (Encrypt, error)

type BytesLoader

type BytesLoader struct {
	Data []byte
}

func (*BytesLoader) GetBytes

func (b *BytesLoader) GetBytes() ([]byte, error)

type Decrypt

type Decrypt interface {
	// DecryptMessage attempts to decode the message into a string.
	// and error will be returned if failed to decode the message.
	DecryptMessage(cipher []byte, nonce []byte) (message []byte, err error)
}

Decrypt represents the ability to decrypt messages

func DefaultCipherDecrypter

func DefaultCipherDecrypter() Decrypt

func NewBasicDecrypter

func NewBasicDecrypter(hash crypto.Hash, recipientPrivateKey *rsa.PrivateKey, senderPublicKey *rsa.PublicKey) Decrypt

func NewBoxDecrypter

func NewBoxDecrypter(recipientPrivateKey [32]byte, senderPublicKey [32]byte) Decrypt

type DecryptLoader

type DecryptLoader interface {
	LoadDecrypt() (Decrypt, error)
}

type Encrypt

type Encrypt interface {
	// EncryptMessage attempts to encode the message into an array of bytes.
	// and error will be returned if failed to encode the message.
	EncryptMessage(message []byte) (crypt []byte, nonce []byte, err error)
}

Encrypt represents the ability to encrypt messages

func DefaultCipherEncrypter

func DefaultCipherEncrypter() Encrypt

func NewBasicEncrypter

func NewBasicEncrypter(hash crypto.Hash, senderPrivateKey *rsa.PrivateKey, recipientPublicKey *rsa.PublicKey) Encrypt

func NewBoxEncrypter

func NewBoxEncrypter(senderPrivateKey [32]byte, recipientPublicKey [32]byte) Encrypt

type EncryptLoader

type EncryptLoader interface {
	LoadEncrypt() (Encrypt, error)
}

type FileLoader

type FileLoader struct {
	Path string
}

func (*FileLoader) GetBytes

func (f *FileLoader) GetBytes() ([]byte, error)

type HashLoader

type HashLoader interface {
	GetHash() (crypto.Hash, error)
}

type KeyLoader

type KeyLoader interface {
	GetBytes() ([]byte, error)
}

type LocalCerts

type LocalCerts struct {
	Path     string
	HashName string
}

type NOOP

type NOOP struct{}

NOOP will just return the message

func (*NOOP) DecryptMessage

func (*NOOP) DecryptMessage(cipher []byte, nonce []byte) (message []byte, err error)

func (*NOOP) EncryptMessage

func (*NOOP) EncryptMessage(message []byte) (crypt []byte, nonce []byte, err error)

type Options

type Options struct {
	// Logger is the go-kit Logger to use for server startup and error logging.  If not
	// supplied, logging.DefaultLogger() is used instead.
	Logger log.Logger `json:"-"`

	Algorithm map[string]interface{} `json:"algorithm,omitempty"`

	SenderPrivateKey    string `json:"senderPrivateKey,omitempty"`
	SenderPublicKey     string `json:"senderPublicKey,omitempty"`
	RecipientPrivateKey string `json:"recipientPrivateKey,omitempty"`
	RecipientPublicKey  string `json:"recipientPublicKey,omitempty"`
}

func FromViper

func FromViper(v *viper.Viper) (*Options, error)

FromViper produces an Options from a (possibly nil) Viper instance. Callers should use FromViper(Sub(v)) if the standard subkey is desired.

func (*Options) LoadDecrypt

func (o *Options) LoadDecrypt() (Decrypt, error)

func (*Options) LoadEncrypt

func (o *Options) LoadEncrypt() (Encrypt, error)