crypt

Dec 4, 2022

Changes in this version

+ const Delimiter

+ func Normalize(encodedDigest string) string

+ type Decoder struct

+ func NewDecoder() *Decoder

+ func NewDecoderAll() (d *Decoder, err error)

+ func NewDefaultDecoder() (d *Decoder, err error)

+ func (d *Decoder) Decode(encodedDigest string) (digest algorithm.Digest, err error)

+ func (d *Decoder) RegisterDecodeFunc(identifier string, decoder algorithm.DecodeFunc) (err error)

+ func (d *Decoder) RegisterDecodePrefix(prefix, identifier string) (err error)

type Digest

+ func NewDigestDecode(encodedDigest string) (digest *Digest, err error)

+ func (d *Digest) MarshalBinary() (data []byte, err error)

+ func (d *Digest) MarshalText() (data []byte, err error)

+ func (d *Digest) Match(password string) (match bool)

+ func (d *Digest) MatchAdvanced(password string) (match bool, err error)

+ func (d *Digest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *Digest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *Digest) Scan(src any) (err error)

+ func (d *Digest) String() string

+ func (d *Digest) UnmarshalBinary(data []byte) (err error)

+ func (d *Digest) UnmarshalText(data []byte) (err error)

+ func (d *Digest) Value() (value driver.Value, err error)

+ type NullDigest struct

+ func NewNullDigest(d algorithm.Digest) (digest *NullDigest)

+ func NewNullDigestDecode(encodedDigest string) (digest *NullDigest, err error)

+ func (d *NullDigest) Encode() string

+ func (d *NullDigest) MarshalBinary() (data []byte, err error)

+ func (d *NullDigest) MarshalText() (data []byte, err error)

+ func (d *NullDigest) Match(password string) (match bool)

+ func (d *NullDigest) MatchAdvanced(password string) (match bool, err error)

+ func (d *NullDigest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *NullDigest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *NullDigest) Scan(src any) (err error)

+ func (d *NullDigest) String() string

+ func (d *NullDigest) UnmarshalBinary(data []byte) (err error)

+ func (d *NullDigest) UnmarshalText(data []byte) (err error)

+ func (d *NullDigest) Value() (value driver.Value, err error)

Aug 31, 2022

Changes in this version

+ const Argon2IterationsMax

+ const Argon2IterationsMin

+ const Argon2KeySizeMax

+ const Argon2KeySizeMin

+ const Argon2MemoryMax

+ const Argon2MemoryMinParallelismMultiplier

+ const Argon2MemoryRoundingParallelismMultiplier

+ const Argon2ParallelismMax

+ const Argon2ParallelismMin

+ const Argon2PasswordInputSizeMax

+ const Argon2SaltSizeMax

+ const Argon2SaltSizeMin

+ const BcryptCostDefault

+ const BcryptCostMax

+ const BcryptCostMin

+ const BcryptPasswordInputSizeMax

+ const KeySizeDefault

+ const PBKDF2IterationsMax

+ const PBKDF2IterationsMin

+ const PBKDF2KeySizeMax

+ const PBKDF2SHA1IterationsDefault

+ const PBKDF2SHA256IterationsDefault

+ const PBKDF2SHA512IterationsDefault

+ const PBKDF2SaltSizeMax

+ const PBKDF2SaltSizeMin

+ const SHA2CryptIterationsDefault

+ const SHA2CryptIterationsMax

+ const SHA2CryptIterationsMin

+ const SHA2CryptSaltSizeMax

+ const SHA2CryptSaltSizeMin

+ const SaltSizeDefault

+ const ScryptBlockSizeDefault

+ const ScryptBlockSizeMax

+ const ScryptBlockSizeMin

+ const ScryptIterationsDefault

+ const ScryptIterationsMin

+ const ScryptKeySizeMax

+ const ScryptKeySizeMin

+ const ScryptParallelismDefault

+ const ScryptParallelismMin

+ const ScryptSaltSizeMax

+ const ScryptSaltSizeMin

Aug 8, 2022

Changes in this version

+ const AlgorithmPrefixArgon2d

+ const AlgorithmPrefixArgon2i

+ const AlgorithmPrefixArgon2id

+ const AlgorithmPrefixBase64

+ const AlgorithmPrefixBcrypt

+ const AlgorithmPrefixBcryptSHA256

+ const AlgorithmPrefixPBKDF2

+ const AlgorithmPrefixPBKDF2SHA1

+ const AlgorithmPrefixPBKDF2SHA224

+ const AlgorithmPrefixPBKDF2SHA256

+ const AlgorithmPrefixPBKDF2SHA384

+ const AlgorithmPrefixPBKDF2SHA512

+ const AlgorithmPrefixPlainText

+ const AlgorithmPrefixSHA256

+ const AlgorithmPrefixSHA512

+ const AlgorithmPrefixScrypt

+ const StorageDelimiter

+ const StorageFormatArgon2

+ const StorageFormatBcrypt

+ const StorageFormatBcryptSHA256

+ const StorageFormatPBKDF2

+ const StorageFormatPrefixLDAPArgon2

+ const StorageFormatPrefixLDAPCrypt

+ const StorageFormatSHACrypt

+ const StorageFormatScrypt

+ const StorageFormatSimple

+ var ErrEncodedHashInvalidFormat = errors.New("provided encoded hash has an invalid format")

+ var ErrEncodedHashInvalidIdentifier = errors.New("provided encoded hash has an invalid identifier")

+ var ErrEncodedHashInvalidOption = errors.New("provided encoded hash has an invalid option")

+ var ErrEncodedHashInvalidOptionKey = errors.New("provided encoded hash has an invalid option key")

+ var ErrEncodedHashInvalidOptionValue = errors.New("provided encoded hash has an invalid option value")

+ var ErrEncodedHashInvalidVersion = errors.New("provided encoded hash has an invalid version")

+ var ErrEncodedHashKeyEncoding = errors.New("provided encoded hash has a key value that can't be decoded")

+ var ErrEncodedHashSaltEncoding = errors.New("provided encoded hash has a salt value that can't be decoded")

+ var ErrKeyDerivation = errors.New("failed to derive the key with the provided parameters")

+ var ErrParameterInvalid = errors.New("parameter is invalid")

+ var ErrPasswordInvalid = errors.New("password is invalid")

+ var ErrSaltEncoding = errors.New("provided salt has a value that can't be decoded")

+ var ErrSaltInvalid = errors.New("salt is invalid")

+ var ErrSaltReadRandomBytes = errors.New("could not read random bytes for salt")

+ func CheckPassword(password, encodedDigest string) (valid bool, err error)

+ func CheckPasswordWithPlainText(password, encodedDigest string) (valid bool, err error)

+ func NormalizeEncodedDigest(encodedDigest string) (out string)

+ type Argon2Digest struct

+ func (d *Argon2Digest) Decode(encodedDigest string) (err error)

+ func (d *Argon2Digest) Encode() (encodedHash string)

+ func (d *Argon2Digest) Match(password string) (match bool)

+ func (d *Argon2Digest) MatchAdvanced(password string) (match bool, err error)

+ func (d *Argon2Digest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *Argon2Digest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *Argon2Digest) String() string

+ type Argon2Hash struct

+ func NewArgon2DHash() *Argon2Hash

+ func NewArgon2Hash() *Argon2Hash

+ func NewArgon2IDHash() *Argon2Hash

+ func NewArgon2IHash() *Argon2Hash

+ func (h *Argon2Hash) CopyParamsTo(hash *Argon2Hash)

+ func (h *Argon2Hash) CopyUnsetParamsTo(hash *Argon2Hash)

+ func (h *Argon2Hash) Hash(password string) (hashed Digest, err error)

+ func (h *Argon2Hash) HashWithSalt(password string, salt []byte) (hashed Digest, err error)

+ func (h *Argon2Hash) MustHash(password string) (hashed Digest)

+ func (h *Argon2Hash) Validate() (err error)

+ func (h *Argon2Hash) WithK(length int) *Argon2Hash

+ func (h *Argon2Hash) WithM(bytes int) *Argon2Hash

+ func (h *Argon2Hash) WithP(parallelism int) *Argon2Hash

+ func (h *Argon2Hash) WithProfile(profile Argon2Profile) *Argon2Hash

+ func (h *Argon2Hash) WithS(length int) *Argon2Hash

+ func (h *Argon2Hash) WithT(time int) *Argon2Hash

+ func (h *Argon2Hash) WithVariant(variant Argon2Variant) *Argon2Hash

+ type Argon2Profile int

+ const Argon2ProfileRFC9106LowMemory

+ const Argon2ProfileRFC9106Recommended

+ func (p Argon2Profile) Params() *Argon2Hash

+ type Argon2Variant int

+ const Argon2VariantD

+ const Argon2VariantI

+ const Argon2VariantID

+ const Argon2VariantNone

+ func NewArgon2Variant(identifier string) (variant Argon2Variant)

+ func (v Argon2Variant) KeyFunc() argon2.KeyFunc

+ func (v Argon2Variant) Prefix() (prefix string)

+ type BcryptDigest struct

+ func (d *BcryptDigest) Decode(encodedDigest string) (err error)

+ func (d *BcryptDigest) Encode() string

+ func (d BcryptDigest) Match(password string) (match bool)

+ func (d BcryptDigest) MatchAdvanced(password string) (match bool, err error)

+ func (d BcryptDigest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d BcryptDigest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d BcryptDigest) String() string

+ type BcryptHash struct

+ func NewBcryptHash() *BcryptHash

+ func NewBcryptSHA256Hash() *BcryptHash

+ func (h *BcryptHash) Hash(password string) (digest Digest, err error)

+ func (h *BcryptHash) HashWithSalt(password string, salt []byte) (digest Digest, err error)

+ func (h *BcryptHash) MustHash(password string) (digest Digest)

+ func (h *BcryptHash) Validate() (err error)

+ func (h *BcryptHash) WithCost(cost int) *BcryptHash

+ func (h *BcryptHash) WithVariant(variant BcryptVariant) *BcryptHash

+ func (h *BcryptHash) WithoutValidation() *BcryptHash

+ type BcryptVariant int

+ const BcryptVariantNone

+ const BcryptVariantSHA256

+ const BcryptVariantStandard

+ func NewBcryptVariant(identifier string) (variant BcryptVariant)

+ func (v BcryptVariant) Encode(cost int, version string, salt, key []byte) (f string)

+ func (v BcryptVariant) EncodeInput(src, salt []byte) (dst []byte)

+ func (v BcryptVariant) PasswordMaxLength() int

+ func (v BcryptVariant) Prefix() (prefix string)

+ type Digest interface

+ Decode func(encodedDigest string) (err error)

+ Encode func() (hash string)

+ func Decode(encodedDigest string) (digest Digest, err error)

+ func DecodeWithPlainText(encodedDigest string) (digest Digest, err error)

+ func NewDigest(encodedDigest string, digest Digest) (d Digest, err error)

+ type Hash interface

+ Hash func(password string) (hashed Digest, err error)

+ HashWithSalt func(password string, salt []byte) (hashed Digest, err error)

+ MustHash func(password string) (hashed Digest)

+ Validate func() (err error)

+ type HashFunc func() hash.Hash

+ type Matcher interface

+ Match func(password string) (match bool)

+ MatchAdvanced func(password string) (match bool, err error)

+ MatchBytes func(passwordBytes []byte) (match bool)

+ MatchBytesAdvanced func(passwordBytes []byte) (match bool, err error)

+ type PBKDF2Digest struct

+ func (d *PBKDF2Digest) Decode(encodedDigest string) (err error)

+ func (d *PBKDF2Digest) Encode() string

+ func (d *PBKDF2Digest) Match(password string) (match bool)

+ func (d *PBKDF2Digest) MatchAdvanced(password string) (match bool, err error)

+ func (d *PBKDF2Digest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *PBKDF2Digest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *PBKDF2Digest) String() string

+ type PBKDF2Hash struct

+ func NewPBKDF2Hash() *PBKDF2Hash

+ func NewPBKDF2SHA1Hash() *PBKDF2Hash

+ func NewPBKDF2SHA224Hash() *PBKDF2Hash

+ func NewPBKDF2SHA256Hash() *PBKDF2Hash

+ func NewPBKDF2SHA384Hash() *PBKDF2Hash

+ func NewPBKDF2SHA512Hash() *PBKDF2Hash

+ func (h *PBKDF2Hash) Hash(password string) (digest Digest, err error)

+ func (h *PBKDF2Hash) HashWithSalt(password string, salt []byte) (digest Digest, err error)

+ func (h *PBKDF2Hash) MustHash(password string) (digest Digest)

+ func (h *PBKDF2Hash) Validate() (err error)

+ func (h *PBKDF2Hash) WithIterations(iterations int) *PBKDF2Hash

+ func (h *PBKDF2Hash) WithKeyLength(bytes int) *PBKDF2Hash

+ func (h *PBKDF2Hash) WithSaltLength(bytes int) *PBKDF2Hash

+ func (h *PBKDF2Hash) WithVariant(variant PBKDF2Variant) *PBKDF2Hash

+ func (h *PBKDF2Hash) WithoutValidation() *PBKDF2Hash

+ type PBKDF2Variant int

+ const PBKDF2VariantNone

+ const PBKDF2VariantSHA1

+ const PBKDF2VariantSHA224

+ const PBKDF2VariantSHA256

+ const PBKDF2VariantSHA384

+ const PBKDF2VariantSHA512

+ func NewPBKDF2Variant(identifier string) (variant PBKDF2Variant)

+ func (v PBKDF2Variant) HashFunc() HashFunc

+ func (v PBKDF2Variant) Prefix() (prefix string)

+ type PlainTextDigest struct

+ func NewBase64Digest(password string) (digest PlainTextDigest)

+ func NewPlainTextDigest(password string) (digest PlainTextDigest)

+ func (d *PlainTextDigest) Decode(encodedDigest string) (err error)

+ func (d *PlainTextDigest) Encode() string

+ func (d *PlainTextDigest) Match(password string) (match bool)

+ func (d *PlainTextDigest) MatchAdvanced(password string) (match bool, err error)

+ func (d *PlainTextDigest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *PlainTextDigest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *PlainTextDigest) String() string

+ type PlainTextVariant int

+ const PlainTextVariantBase64

+ const PlainTextVariantNone

+ const PlainTextVariantPlainText

+ func NewPlainTextVariant(identifier string) (variant PlainTextVariant)

+ func (v PlainTextVariant) Decode(src string) (dst []byte, err error)

+ func (v PlainTextVariant) Encode(src []byte) (dst string)

+ func (v PlainTextVariant) Prefix() (prefix string)

+ type SHA2CryptDigest struct

+ func (d *SHA2CryptDigest) Decode(encodedDigest string) (err error)

+ func (d *SHA2CryptDigest) Encode() (hash string)

+ func (d SHA2CryptDigest) Match(password string) (match bool)

+ func (d SHA2CryptDigest) MatchAdvanced(password string) (match bool, err error)

+ func (d SHA2CryptDigest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d SHA2CryptDigest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d SHA2CryptDigest) String() string

+ type SHA2CryptHash struct

+ func NewSHA2CryptHash() *SHA2CryptHash

+ func NewSHA2CryptSHA256Hash() *SHA2CryptHash

+ func NewSHA2CryptSHA512Hash() *SHA2CryptHash

+ func (h *SHA2CryptHash) Hash(password string) (digest Digest, err error)

+ func (h *SHA2CryptHash) HashWithSalt(password string, salt []byte) (digest Digest, err error)

+ func (h *SHA2CryptHash) MustHash(password string) (digest Digest)

+ func (h *SHA2CryptHash) Validate() (err error)

+ func (h *SHA2CryptHash) WithRounds(rounds int) *SHA2CryptHash

+ func (h *SHA2CryptHash) WithSHA256() *SHA2CryptHash

+ func (h *SHA2CryptHash) WithSHA512() *SHA2CryptHash

+ func (h *SHA2CryptHash) WithSaltLength(bytes int) *SHA2CryptHash

+ func (h *SHA2CryptHash) WithVariant(variant SHA2CryptVariant) *SHA2CryptHash

+ func (h *SHA2CryptHash) WithoutValidation() *SHA2CryptHash

+ type SHA2CryptVariant int

+ const SHA2CryptVariantNone

+ const SHA2CryptVariantSHA256

+ const SHA2CryptVariantSHA512

+ func NewSHA2CryptVariant(identifier string) SHA2CryptVariant

+ func (v SHA2CryptVariant) HashFunc() HashFunc

+ func (v SHA2CryptVariant) Name() (s string)

+ func (v SHA2CryptVariant) Prefix() (prefix string)

+ type ScryptDigest struct

+ func (d *ScryptDigest) Decode(encodedDigest string) (err error)

+ func (d *ScryptDigest) Encode() string

+ func (d *ScryptDigest) Match(password string) (match bool)

+ func (d *ScryptDigest) MatchAdvanced(password string) (match bool, err error)

+ func (d *ScryptDigest) MatchBytes(passwordBytes []byte) (match bool)

+ func (d *ScryptDigest) MatchBytesAdvanced(passwordBytes []byte) (match bool, err error)

+ func (d *ScryptDigest) String() string

+ type ScryptHash struct

+ func NewScryptHash() *ScryptHash

+ func (h *ScryptHash) Hash(password string) (digest Digest, err error)

+ func (h *ScryptHash) HashWithSalt(password string, salt []byte) (digest Digest, err error)

+ func (h *ScryptHash) MustHash(password string) (digest Digest)

+ func (h *ScryptHash) Validate() (err error)

+ func (h *ScryptHash) WithKeySize(size int) *ScryptHash

+ func (h *ScryptHash) WithLN(rounds int) *ScryptHash

+ func (h *ScryptHash) WithP(parallelism int) *ScryptHash

+ func (h *ScryptHash) WithR(blockSize int) *ScryptHash

+ func (h *ScryptHash) WithSaltSize(size int) *ScryptHash