crypka

type AEADSymmEncAlgo ¶

type AEADSymmEncAlgo struct {
	KeyLength   int
	NonceLength int

	NonceConfig NonceConfig

	AEADFactory func(key []byte) (aead cipher.AEAD, err error)
}

func (algo *AEADSymmEncAlgo) GenerateKey(ctx KeyGenerationContext, rng RNG) (key EncSymmKey, err error)

func (algo *AEADSymmEncAlgo) GetInfo() EncAlgoInfo

func (algo *AEADSymmEncAlgo) ParseSymmEncKey(ctx KeyParseContext, data []byte) (key EncSymmKey, err error)

type AlgorithmType ¶

type AlgorithmType uint8

const (
	SymmEncAlgorithmType  AlgorithmType = 1
	AsymEncAlgorithmType  AlgorithmType = 2
	HashAlgorithmType     AlgorithmType = 3
	SymmSignAlgorithmType AlgorithmType = 4
	AsymSignAlgorithmType AlgorithmType = 5
	RNGAlgorithmType      AlgorithmType = 6
	KXAlgorithmType       AlgorithmType = 7
)

type AnyContext ¶

type AnyContext = *Context

type Argon2PasswordHash ¶ added in v0.0.2

type Argon2PasswordHash struct {
	Name string
	Salt []byte
	Hash []byte

	Version int

	Time    uint32
	Memory  uint32
	Threads uint8
}

PHCPasswordHash encoded in PHC format

func (h *Argon2PasswordHash) GetAlgo() string

func (dh *Argon2PasswordHash) Load(r io.ByteReader) (err error)

func (h *Argon2PasswordHash) Raw() (res []byte, err error)

type Argon2PasswordHasher ¶ added in v0.0.2

type Argon2PasswordHasher struct {
	// Defaults to argon2id
	AlgoName string

	SaltLength uint32
	KeyLength  uint32

	Memory  uint32
	Time    uint32
	Threads uint8

	RNG RNG
}

func (h *Argon2PasswordHasher) CheckPassword(ctx PasswordHashContext, password, hash []byte) (err error)

func (h *Argon2PasswordHasher) HashPassword(ctx PasswordHashContext, password, appendTo []byte) (res []byte, err error)

type BaseAlgorithmInfo ¶

type BaseAlgorithmInfo struct {
	Type AlgorithmType

	// Is this algorithm cryptographically secure.
	// This may change if algorithm is discovered to be insecure.
	IsSecure bool
}

type BlankEncSymmAlgo ¶

type BlankEncSymmAlgo struct {
}

WARNING: This algorithm is FOR TESTING ONLY. IT DOES NOTHING, IT JUST COPIES DATA!!! It turns out however, to be useful for testing.

func (algo *BlankEncSymmAlgo) GenerateKey(ctx KeyGenerationContext, rng RNG) (sk EncSymmKey, err error)

func (algo *BlankEncSymmAlgo) GetInfo() EncAlgoInfo

func (algo *BlankEncSymmAlgo) ParseSymmEncKey(ctx KeyParseContext, data []byte) (ek EncSymmKey, err error)

type CPKStreamSymmEncAlgo ¶

type CPKStreamSymmEncAlgo struct {
	EncSymmAlgo
}

Implements algorithm, which handles streamming encryption in crypka's format.

func (algo *CPKStreamSymmEncAlgo) GenerateKey(ctx KeyGenerationContext, rng RNG) (key EncSymmKey, err error)

func (algo *CPKStreamSymmEncAlgo) GetInfo() EncAlgoInfo

func (algo *CPKStreamSymmEncAlgo) ParseSymmEncKey(ctx KeyParseContext, data []byte) (key EncSymmKey, err error)

type CompressSigningKey ¶

type CompressSigningKey struct {
	Compressor   SigningKey
	ActualSigner func(ctx KeyContext, data []byte) (sign []byte, err error)
}

func (k *CompressSigningKey) MakeSigner(ctx KeyContext) (signer Signer, err error)

type CompressVerifier ¶

type CompressVerifier struct {
	Ctx            KeyContext
	Compressor     Signer
	ActualVerifier func(ctx KeyContext, sign, data []byte) (err error)
}

func (s *CompressVerifier) Verify(sign []byte) (err error)

func (s *CompressVerifier) Write(data []byte) (sz int, err error)

type CompressVerifyingKey ¶

type CompressVerifyingKey struct {
	Compressor     SigningKey
	ActualVerifier func(ctx KeyContext, sign, data []byte) (err error)
}

func (k *CompressVerifyingKey) MakeVerifier(ctx KeyContext) (verifier Verifier, err error)

type Context ¶

type Context struct {
	RNG              RNG
	SetInsecureTaint bool
}

func MakeDefaultContext() *Context

type CounterNonceManager ¶

type CounterNonceManager struct {
	Nonce  []byte
	Unsafe bool
}

CounterNonceManager is preallocated slice of specified size, which can be efficiently incremented by one in order to produce unique nonces for data encryption.

NOTE: THIS IS NOT CONSTANT TIME!!! Be aware that this counter leaks(or may leak) count of chunks encrypted already. Usually this is not problem, since attacker knows anyway how many chunks were encrypted.

func NewNonceCounterManager(sz int, unsafe bool) *CounterNonceManager

func (nm CounterNonceManager) GetNonce() []byte

func (nm CounterNonceManager) Len() int

func (nm CounterNonceManager) NextNonce() (err error)

type CryptoRNGAlgo ¶

type CryptoRNGAlgo struct {
}

RNG which uses crypto/rand.Reader to provide RNG.

func (algo *CryptoRNGAlgo) GetInfo() RNGAlgoInfo

func (algo *CryptoRNGAlgo) MakeRng(ctx RNGGenerationContext, seed []byte) (rng RNG, err error)

type DecKey ¶

type DecKey interface {
	MakeDecryptor(ctx KeyContext) (Decryptor, error)
}

type Decryptor ¶

type Decryptor interface {
	GetEncInfo() EncInfo

	Decrypt(in, appendTo []byte) (res []byte, err error)
	Finalize() (err error)
}

type DefaultStructHashWriter ¶ added in v0.0.2

type DefaultStructHashWriter struct {
}

Note: this writer does not differnciate empty and nil slice, just like golang STL in functions like len.

func (dsh *DefaultStructHashWriter) WriteStruct(ctx HashContext, res interface{}, w io.Writer) (err error)

type Ed25519SignAsymAlgo ¶

type Ed25519SignAsymAlgo struct {
	Compressor SigningKey
}

Ed25519SignAsymAlgo, which uses compressor given to prevent buffering data before signing. This allows for easier signing of arbitrarily sized data.

func (a *Ed25519SignAsymAlgo) GenerateKeyPair(ctx KeyGenerationContext, rng RNG) (sk SigningKey, vk VerifyingKey, err error)

func (a *Ed25519SignAsymAlgo) GetInfo() SignAlgoInfo

func (a *Ed25519SignAsymAlgo) ParseSigningKey(ctx KeyParseContext, key []byte) (sk SigningKey, err error)

func (a *Ed25519SignAsymAlgo) ParseVerifyingKey(ctx KeyParseContext, key []byte) (vk VerifyingKey, err error)

type EncAlgo ¶

type EncAlgo interface {
	GetInfo() EncAlgoInfo
}

type EncAlgoInfo ¶

type EncAlgoInfo struct {
	BaseAlgorithmInfo
	EncInfo

	AuthMode EncAuthMode
}

type EncAsymAlgo ¶

type EncAsymAlgo interface {
	EncAlgo
	EncAsymKeygen
	EncAsymKeyParser
}

type EncAsymKXAlgo ¶

type EncAsymKXAlgo struct {
	EncSymmAlgo EncSymmAlgo
	KXAlgo      KXAlgo

	// Max size of ephemeral key length.
	// Ignored during encryption, used for decryption only.
	// Defaults to 1MB.
	MaxMarshaledEphemeralLength int

	// How many bytes should be loaded from KX.
	KXResultLength int

	// Optional, used to extend KX result to key.
	// Raw value used, if not present.
	// Value is truncated to as many bytes as needed by symmetric algo.
	RNGAlgo RNGAlgo

	// RNG to use to generate ephemeral keys.
	// One from context used if nil.
	EphemeralRNG RNG
}

EncAsymKXAlgo makes asymmetric encryption algorithm from symmetric encryption one and key exchange one. It's secure, unless used algorithms are secure. Since X25519 exists, it's preferred way to implement asymmetric encryption in application, when used along with ChaCha or AES.

func (algo *EncAsymKXAlgo) GenerateKeyPair(ctx KeyGenerationContext, rng RNG) (ek EncKey, dk DecKey, err error)

func (algo *EncAsymKXAlgo) GetInfo() EncAlgoInfo

func (algo *EncAsymKXAlgo) ParseDecKey(ctx KeyParseContext, data []byte) (dk DecKey, err error)

func (algo *EncAsymKXAlgo) ParseEncKey(ctx KeyParseContext, data []byte) (ek EncKey, err error)

type EncAsymKeyParser ¶

type EncAsymKeyParser interface {
	ParseEncKey(ctx KeyParseContext, data []byte) (EncKey, error)
	ParseDecKey(ctx KeyParseContext, data []byte) (DecKey, error)
}

type EncAsymKeygen ¶

type EncAsymKeygen interface {
	GenerateKeyPair(ctx KeyGenerationContext, rng RNG) (EncKey, DecKey, error)
}

type EncAuthMode ¶

type EncAuthMode uint32

Note: rest of bits of this value is reserved for future use. They must not be used by any implementation.

const NotAuthenticatedEncAuthMode EncAuthMode = 0

func (eam *EncAuthMode) IsEagerAuthenticated() bool

func (eam *EncAuthMode) IsFinalizeAuthetnicated() bool

func (eam *EncAuthMode) IsTruncAuthenticated() bool

func (eam *EncAuthMode) IsZero() bool

func (eam *EncAuthMode) SetEagerAuthenticated(to bool)

func (eam *EncAuthMode) SetFinalizeAuthetnicated(to bool)

func (eam *EncAuthMode) SetTruncAuthenticated(to bool)

type EncInfo ¶

type EncInfo struct {
	RequiresFinalization bool
	EncType              EncType
}

Note: this structure contains only basic information about encryption algorithm. In particular kind and if it requires finalization.

Note #2: this structure should contain only data, which is required to run encryption properly.

For more information about specified encryption scheme algorithm should be used.

type EncKey ¶

type EncKey interface {
	MakeEncryptor(ctx KeyContext) (Encryptor, error)
}

type EncStreamRNGAlgo ¶

type EncStreamRNGAlgo struct {
	CipherFactory           func(key []byte) (res cipher.Stream, err error)
	KeyLength               int
	ResedKeyLength          int // if zero, then no reseeding will happen
	CipherMaxGeneratedBytes uint64
}

RNG, which uses some stream encryption algorithm in order to generate random data from small seed. It automatically reseeds RNG when it's about to reach it's max generated bytes.

func (algo *EncStreamRNGAlgo) GetInfo() RNGAlgoInfo

func (algo *EncStreamRNGAlgo) MakeRng(ctx RNGGenerationContext, seed []byte) (rng RNG, err error)

type EncSymmAlgo ¶

type EncSymmAlgo interface {
	EncAlgo
	EncSymmKeygen
	EncSymmKeyParser
}

type EncSymmKey ¶

type EncSymmKey interface {
	EncKey
	DecKey
}

type EncSymmKeyParser ¶

type EncSymmKeyParser interface {
	ParseSymmEncKey(ctx KeyParseContext, data []byte) (EncSymmKey, error)
}

type EncSymmKeygen ¶

type EncSymmKeygen interface {
	GenerateKey(ctx KeyGenerationContext, rng RNG) (EncSymmKey, error)
}

type EncType ¶

type EncType uint8

Defines relations between subsequent call to Encrypt/Decrypt functions. See specific types for more details.

const (
	// Block encryption encrypts(decrypts) each block atomically.
	// Blocks are independent of each other.
	//
	// Note: this should not be mistaken with block encryption from crypto world in general ie. fixed block size.
	// This one is more like AEAD encryption(think of box/sealedbox from nacl)
	EncTypeBlock EncType = 1

	// This kind of encryption requires that chunks passed for decryption are passed in same order(it MAY NOT be checked however)
	// that they were passed for encryption.
	//
	// Also no slicing is allowed. Each chunk yielded from encrypt must be passed in same and unmodified form to decrypt.
	EncTypeChain EncType = 2

	// It's just like EncTypeChain, but allows slicing. Passing partial chunks to decrypt is allowed.
	EncTypeStream EncType = 3
)

type Encryptor ¶

type Encryptor interface {
	GetEncInfo() EncInfo

	Encrypt(in, appendTo []byte) (res []byte, err error)
	Finalize(appendTo []byte) (res []byte, err error)
}

type HMACSignAlgorithm ¶

type HMACSignAlgorithm struct {
	Hash         crypto.Hash
	MinKeyLength int
	MaxKeyLength int
	GenKeyLength int
}

HMACSignAlgorithm wraps golang's stl HMAC type and makes it crypka's HMAC types.

func (a *HMACSignAlgorithm) GenerateKey(ctx KeyGenerationContext, rng RNG) (key SymmSignKey, err error)

func (a *HMACSignAlgorithm) GetInfo() SignAlgoInfo

func (a *HMACSignAlgorithm) ParseSymmSignKey(ctx KeyGenerationContext, data []byte) (key SymmSignKey, err error)

type HashCompressRNGAlgo ¶

type HashCompressRNGAlgo struct {
	Compressor    SigningKey
	InnerAlgo     RNGAlgo
	MinSeedLength int
}

Algorithm, which uses hash function to compress seed of arbitrary size into one appropriate for RNG. It's allowed for hash to return more data than RNG seed needs, but it must not yield less than required.

If provided more data than requried, then only part of hash is used.

func (algo *HashCompressRNGAlgo) GetInfo() RNGAlgoInfo

func (algo *HashCompressRNGAlgo) MakeRng(ctx RNGGenerationContext, seed []byte) (rng RNG, err error)

type HashContext ¶ added in v0.0.2

type HashContext = *Context

type HashSignAlgorithm ¶

type HashSignAlgorithm struct {
	Hash crypto.Hash
}

HashSignAlgorithm wraps golang's stl hash type and makes it crypka's hash types.

func (a *HashSignAlgorithm) GenerateKey(ctx KeyGenerationContext, rng RNG) (SymmSignKey, error)

func (a *HashSignAlgorithm) GetInfo() SignAlgoInfo

func (a *HashSignAlgorithm) ParseSymmSignKey(ctx KeyParseContext, data []byte) (SymmSignKey, error)

type HashableHelper ¶

type HashableHelper struct {
	W io.Writer
}

Provides a few extension functions, which HashableWriter does not have, but are useful when implementing.

func (util *HashableHelper) EnterSlice(length int) (err error)

func (util *HashableHelper) EnterStruct() (err error)

func (util *HashableHelper) ExitSlice() (err error)

func (util *HashableHelper) ExitStruct() (err error)

func (util *HashableHelper) WriteByteSlice(data []byte) (err error)

func (util *HashableHelper) WriteConstBytes(data []byte) (err error)

func (util *HashableHelper) WriteInt(v int) (err error)

func (util *HashableHelper) WriteInt16(v int16) (err error)

func (util *HashableHelper) WriteInt32(v int32) (err error)

func (util *HashableHelper) WriteInt64(v int64) (err error)

func (util *HashableHelper) WriteInt8(v int8) (err error)

func (util *HashableHelper) WriteSlice(length int, writer func(hh *HashableHelper) (err error)) (err error)

func (util *HashableHelper) WriteString(data string) (err error)

func (util *HashableHelper) WriteStruct(writer func(hh *HashableHelper) (err error)) (err error)

func (util *HashableHelper) WriteUint16(v uint16) (err error)

func (util *HashableHelper) WriteUint32(v uint32) (err error)

func (util *HashableHelper) WriteUint64(v uint64) (err error)

func (util *HashableHelper) WriteUint8(v uint8) (err error)

func (util *HashableHelper) WriteVarBytes(data []byte) (err error)

type HashableNew ¶ added in v0.0.2

type HashableNew interface {
	HashSelf(w *HashableHelper) (err error)
}

type KXAlgo ¶

type KXAlgo interface {
	KXParser
	KXExchanger
	KXKeygen
	GetInfo() KXAlgorithmInfo
}

type KXAlgorithmInfo ¶

type KXAlgorithmInfo struct {
	BaseAlgorithmInfo
	MaxResLen int
}

type KXExchanger ¶

type KXExchanger interface {
	PerformExchange(ctx KeyContext, public KXPublic, secret KXSecret, res []byte) (err error)
}

type KXKeygen ¶

type KXKeygen interface {
	GenerateKXPair(ctx KeyGenerationContext, rng RNG) (public KXPublic, secret KXSecret, err error)
}

type KXParser ¶

type KXParser interface {
	ParseKXPublic(ctx KeyParseContext, data []byte) (KXPublic, error)
	ParseKXSecret(ctx KeyParseContext, data []byte) (KXSecret, error)
}

type KXPublic ¶

type KXPublic interface {
}

type KXRngAlgo ¶

type KXRngAlgo struct {
	KXAlgo
	RNGAlgo RNGAlgo

	RNGSeedBytes int
}

KX Algorithm, which expands result of KX using RNG. It uses RNGseedBytes if not zero. It uses maximum possible RNG seed size. If max size from both algorithms is infinite, then uses 64 bytes. Panics if RNG requires larger seed than KX algo is able to generate.

func (algo *KXRngAlgo) GetInfo() KXAlgorithmInfo

func (algo *KXRngAlgo) PerformExchange(ctx KeyContext, public KXPublic, secret KXSecret, res []byte) (err error)

type KXSecret ¶

type KXSecret interface {
}

type KeyContext ¶

type KeyContext = *Context

type KeyGenerationContext ¶

type KeyGenerationContext = *Context

type KeyParseContext ¶

type KeyParseContext = *Context

type MarshalableKey ¶

type MarshalableKey interface {
	MarshalToWriter(w io.Writer) (err error)
}

Represents key, which may be serialized. Key serialized in such way should be parsable by algorithm.

# Marshalling note Please note that keys shouldn't be marshalled in any other way. This is the only legit way, which provides security against leaking some redundant data.

type MathRNGAlgo ¶

type MathRNGAlgo struct {
}

RNG which uses math/rand to provide RNG. It's not secure.

func (algo *MathRNGAlgo) GetInfo() RNGAlgoInfo

func (algo *MathRNGAlgo) MakeRng(ctx RNGGenerationContext, seed []byte) (rng RNG, err error)

type NonceConfig ¶

type NonceConfig struct {
	NonceType NonceType

	// If true, disables all checks in encryptor, which prevent user from producing too many ciphertexts.
	AllowUnsafe bool
}

Defines how specified algoritm should manage nonce. Please note that changing it may change algorithm characteristics.

func (config *NonceConfig) MakeNonceManager(ctx KeyContext, length int) (nm NonceManager, err error)

type NonceManager ¶

type NonceManager interface {
	GetNonce() []byte
	NextNonce() (err error)
}

type NonceType ¶

type NonceType uint8

const (
	// Instructs algorithm to use nonce counter to manage nonces.
	// Allows producing 2^(bytes of nonce) blocks.
	//
	// WARNING! After using this mode nothing should be encrypted with the same key.
	CounterNonce NonceType = 1

	// Instructs algorithm to use RNG to manage nonces.
	// Allows producing 2^(bytes of nonce / 2) blocks.
	//
	// WARNING when using multiple encryptors for encryption it's user responsibility not to exceed above number.
	// Note: some algorithms like XChaCha20 have nonce so big, that for any real world usage infinite amount of ciphertexts may be produced.
	RNGNonce NonceType = 2
)

type PHash ¶ added in v0.0.2

type PHash interface {
	GetAlgo() string // returns name of hashing algorithm used
	Raw() []byte     // returns encoded form of hash, so if it was parsed again, it would yield same result
}

type PHashAlgoInfo ¶ added in v0.0.2

type PHashAlgoInfo struct {
	Name   string
	Secure bool
}

type PHasher ¶ added in v0.0.2

type PHasher interface {
	GetInfo() PHashAlgoInfo
	HashPassword(ctx PasswordHashContext, password []byte, appendTo []byte) (res []byte, err error)
	CheckPassword(ctx PasswordHashContext, password, hash []byte) (err error)
}

PHasher are special kind of hashes. Rather than stream data, they accept constant-sized data and yield hash of it.

type Padder ¶

type Padder interface {
	Pad(data []byte, msgSize int) []byte
}

Padder is something able to apply padding to message.

type PadderFunc ¶

type PadderFunc func(data []byte, msgSize int) []byte

PadderFunc is function which is Padder.

func (f PadderFunc) Pad(data []byte, msgSize int) []byte

type Padding ¶

type Padding interface {
	Padder
	Unpadder
}

func PaddingIEC78164() Padding

type PasswordHashContext ¶ added in v0.0.2

type PasswordHashContext = *Context

type RNG ¶

type RNG interface {
	io.Reader
}

Base RNG type. Base RNG is simple reader. It may implement additional interfaces.

func ContextGetRNG(ctx *Context) RNG

func FallbackContextGetRNG(ctx *Context, rng RNG) RNG

type RNGAlgo ¶

type RNGAlgo interface {
	GetInfo() RNGAlgoInfo
	MakeRng(ctx RNGGenerationContext, seed []byte) (rng RNG, err error)
}

type RNGAlgoInfo ¶

type RNGAlgoInfo struct {
	BaseAlgorithmInfo
	RNGType           RNGType
	MaxGeneratedBytes uint64 // 0 corresponds to infinite
	MinSeedLength     int    // 0 if no seed
	MaxSeedLength     int    // 0 if no seed, ^0 max value if unlimited
}

type RNGGenerationContext ¶

type RNGGenerationContext = *Context

type RNGNonceManager ¶

type RNGNonceManager struct {
	Nonce  []byte
	RNG    io.Reader
	Unsafe bool
	// contains filtered or unexported fields
}

func (nm *RNGNonceManager) GetNonce() []byte

func (nm *RNGNonceManager) Initialize() (err error)

func (nm *RNGNonceManager) NextNonce() (err error)

type RNGType ¶

type RNGType uint8

const (
	// RNG, which was created from some seed. It may generate finite amount of random data before looping.
	SeedRNGType RNGType = 1

	// RNG, which collects entropy from environment(most of the time os does that).
	// It generates infinite amount of random data and can't be constructed with seed.
	EnvRNGType RNGType = 2
)

type RegisterEd25519Options ¶

type RegisterEd25519Options struct {
	CompressorData []struct {
		Suffix     string
		Compressor SigningKey
	}
}

type RegisterSTLHMACsOptions ¶

type RegisterSTLHMACsOptions struct {
	MinKeyLength int
	GenKeyLength int
}

type Registry ¶

type Registry interface {
	RegisterAlgo(name string, algo interface{})
	GetAlgo(name string) (algo interface{})
	Lock()

	GetAlgorithmTyped(name string, dstAlgo interface{}) (err error)
}

Registry for any kind of algorithm.

func NewRegistry() Registry

type SerializedKey ¶

type SerializedKey struct {
	Algo string
	Type SerializedKeyType
	Data []byte
}

type SerializedKeyType ¶

type SerializedKeyType uint8

type SignAlgo ¶

type SignAlgo interface {
	GetInfo() SignAlgoInfo
}

type SignAlgoInfo ¶

type SignAlgoInfo struct {
	BaseAlgorithmInfo
}

type SignAsymAlgo ¶

type SignAsymAlgo interface {
	SignAlgo
	SignAsymKeyGen
	SignAsymKeyParser
}

type SignAsymKeyGen ¶

type SignAsymKeyGen interface {
	GenerateKeyPair(ctx KeyGenerationContext, rng RNG) (SigningKey, VerifyingKey, error)
}

type SignAsymKeyParser ¶

type SignAsymKeyParser interface {
	ParseSigningKey(ctx KeyParseContext, data []byte) (SigningKey, error)
	ParseVerifyingKey(ctx KeyParseContext, data []byte) (VerifyingKey, error)
}

type SignSymmAlgo ¶

type SignSymmAlgo interface {
	SignAlgo
	SignSymmKeyGen
	SignSymmKeyParser
}

type SignSymmKeyGen ¶

type SignSymmKeyGen interface {
	GenerateKey(ctx KeyGenerationContext, rng RNG) (SymmSignKey, error)
}

type SignSymmKeyParser ¶

type SignSymmKeyParser interface {
	ParseSymmSignKey(ctx KeyParseContext, data []byte) (SymmSignKey, error)
}

type Signer ¶

type Signer interface {
	io.Writer

	Finalize(appendTo []byte) ([]byte, error)
}

type SigningKey ¶

type SigningKey interface {
	MakeSigner(key KeyContext) (Signer, error)
}

type StructHashWriter ¶ added in v0.0.2

type StructHashWriter interface {
	WriteStruct(ctx HashContext, data interface{}, w io.Writer) (err error)
}

StructHashWriter manages process of writing arbitrary typed data into writer.

Note: it's not correct to use this multiple times on same signer. Security guarantees do not hold then. Use slice of values instead.

type StructHasher ¶ added in v0.0.2

type StructHasher interface {
	HashStruct(ctx HashContext, data interface{}) (res []byte, err error)
}

StructHash consumes arbitrary input and produces hash from in form of byte slice.

Note: when this type is too narrow and it does not fit the use case(like signing), StructHashWriter should be preferred.

type StructHasherImpl ¶ added in v0.0.2

type StructHasherImpl struct {
	// Note: SK given *should* be hash.
	SigningKey SigningKey
	Writer     StructHashWriter // optional; default used if unset
}

func (sh *StructHasherImpl) HashStruct(ctx HashContext, data interface{}) (res []byte, err error)

type SymmSignKey ¶

type SymmSignKey interface {
	SigningKey
	VerifyingKey
}

SymmSignKey even though, it at first sight may seem useless, its quite useful. Usually this is implemented by HMACs and hashers(in case of hashes key is always constant and zero-length, but abstraction still works).

type Unpadder ¶

type Unpadder interface {
	// Unpad returns value < 0 if it failed
	Unpad(data []byte) (msgSize int)
}

Unpadder is something able to remove padding.

type UnpadderFunc ¶

type UnpadderFunc func(data []byte) (msgSize int)

UnpadderFunc if cuntion which is Unpadder.

func (f UnpadderFunc) Unpad(data []byte) (msgSize int)

type Verifier ¶

type Verifier interface {
	io.Writer

	Verify(sign []byte) error
}

type VerifyingKey ¶

type VerifyingKey interface {
	MakeVerifier(ctx KeyContext) (Verifier, error)
}

type X25519KXAlgo ¶

type X25519KXAlgo struct{}

func (algo *X25519KXAlgo) GenerateKXPair(ctx KeyGenerationContext, rng RNG) (public KXPublic, secret KXSecret, err error)

func (algo *X25519KXAlgo) GetInfo() KXAlgorithmInfo

func (algo *X25519KXAlgo) ParseKXPublic(ctx KeyParseContext, data []byte) (pub KXPublic, err error)

func (algo *X25519KXAlgo) ParseKXSecret(ctx KeyParseContext, data []byte) (sec KXSecret, err error)

func (algo *X25519KXAlgo) PerformExchange(ctx KeyContext, public KXPublic, secret KXSecret, res []byte) (err error)

type XorEncSymmAlgo ¶

type XorEncSymmAlgo struct {
	MinKeyLength      int
	MaxKeyLength      int
	GenerateKeyLength int
}

WARNING: This algorithm is FOR TESTING ONLY. DO NOT USE IT IN PRODUCTION ANYTIME EVER!

func (algo *XorEncSymmAlgo) GenerateKey(ctx KeyGenerationContext, rng RNG) (sk EncSymmKey, err error)

func (algo *XorEncSymmAlgo) GetInfo() EncAlgoInfo

func (algo *XorEncSymmAlgo) ParseSymmEncKey(ctx KeyParseContext, data []byte) (ek EncSymmKey, err error)