cipher

Documentation

Overview

cipher package is a helper package for encrypting and decrypting messages

Index

• func GeneratePrivateKey(size int) *rsa.PrivateKey
• func GetHash(hashType string) crypto.Hash
• type BasicHashLoader
  • func (b *BasicHashLoader) GetHash() (crypto.Hash, error)
• type Decrypt
• type Enrypt
• type FileLoader
  • func (f *FileLoader) GetBytes() ([]byte, error)
• type HashLoader
• type KeyLoader
• type LoadConfig
• type LocalCerts
• type NOOP
  • func (noop *NOOP) DecryptMessage(cipher []byte) ([]byte, error)
  • func (noop *NOOP) EncryptMessage(message []byte) ([]byte, error)
  • func (noop *NOOP) Sign(message []byte) ([]byte, error)
  • func (noop *NOOP) VerifyMessage(message []byte, signature []byte) bool
• type PrivateKeyCipher
  • func LoadPrivate(v *viper.Viper) (PrivateKeyCipher, error)
  • func LoadPrivateKey(config LoadConfig) (PrivateKeyCipher, error)
  • func NewPrivateCrypter(hash crypto.Hash, key *rsa.PrivateKey) PrivateKeyCipher
• type PublicKeyCipher
  • func LoadPublic(v *viper.Viper) (PublicKeyCipher, error)
  • func LoadPublicKey(config LoadConfig) (PublicKeyCipher, error)
  • func NewPublicCrypter(hash crypto.Hash, key *rsa.PublicKey) PublicKeyCipher
• type Sign
• type Verify

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

Types

type BasicHashLoader

type BasicHashLoader struct {
	HashName string
}

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 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) ([]byte, error)
}

Decrypt represents the ability to decrypt messages

type Enrypt

type Enrypt 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) ([]byte, error)
}

Enrypt represents the ability to encrypt messages

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 LoadConfig

type LoadConfig struct {
	Hash HashLoader
	Key  KeyLoader
}

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 *NOOP) DecryptMessage(cipher []byte) ([]byte, error)

func (*NOOP) EncryptMessage

func (noop *NOOP) EncryptMessage(message []byte) ([]byte, error)

func (*NOOP) Sign

func (noop *NOOP) Sign(message []byte) ([]byte, error)

func (*NOOP) VerifyMessage

func (noop *NOOP) VerifyMessage(message []byte, signature []byte) bool

type PrivateKeyCipher

type PrivateKeyCipher interface {
	Decrypt
	Sign
}

PrivateKeyCipher handles functionality provided with a privateKey

func LoadPrivate

func LoadPrivate(v *viper.Viper) (PrivateKeyCipher, error)

func LoadPrivateKey

func LoadPrivateKey(config LoadConfig) (PrivateKeyCipher, error)

func NewPrivateCrypter

func NewPrivateCrypter(hash crypto.Hash, key *rsa.PrivateKey) PrivateKeyCipher

type PublicKeyCipher

type PublicKeyCipher interface {
	Enrypt
	Verify
}

PrivateKeyCipher handles functionality provided with a publicKey

func LoadPublic

func LoadPublic(v *viper.Viper) (PublicKeyCipher, error)

func LoadPublicKey

func LoadPublicKey(config LoadConfig) (PublicKeyCipher, error)

func NewPublicCrypter

func NewPublicCrypter(hash crypto.Hash, key *rsa.PublicKey) PublicKeyCipher

type Sign

type Sign interface {
	// Sign attempts to sign the message into an array of bytes
	// and an error will be returned if a failure is encountered while signing the message.
	Sign(message []byte) ([]byte, error)
}

Sign is used to sign the signature of a message

type Verify

type Verify interface {
	// VerifyMessage will return true if the message was successfully verified
	VerifyMessage(message []byte, signature []byte) bool
}

Verify is used to sign and verify the signature of a message