security

package

Go to main page

Versions in this module

v0

v0.70.0

Dec 27, 2023

Changes in this version

+ const ApplicationCtxKey

+ const PrincipalCtxKey

+ var ErrPasswordLength = errors.New("password length is too short")

+ func AddApplicationToContext(ctx *gin.Context, application string)

+ func AddPrincipalToContext(ctx *gin.Context, principal *Principal)

+ func GetApplicationFromContext(ctx *gin.Context) (string, bool)

type AuthenticationService

+ Validate func(principal *Principal) []error

type DefaultAuthenticationService

+ func (service *DefaultAuthenticationService) Validate(principal *Principal) []error

type JwtTokenManagerOption

+ func WithSigningKey(signingKey any) JwtTokenManagerOption

+ func WithVerifyingKey(verifyingKey any) JwtTokenManagerOption

type MockAuthenticationService

+ func (m *MockAuthenticationService) Validate(principal *Principal) []error

type MockAuthenticationServiceMockRecorder

+ func (mr *MockAuthenticationServiceMockRecorder) Validate(principal any) *gomock.Call

type Principal

+ func GetPrincipalFromContext(ctx *gin.Context) (*Principal, bool)

v0.5.1

Sep 15, 2023

v0.5.0

Sep 15, 2023

Changes in this version

+ var ErrAccountDisabled = errors.New("principal is disabled")

+ var ErrAccountEmptyAuthorities = errors.New("principal authorities are empty")

+ var ErrAccountEmptyPassphrase = errors.New("principal passphrase is empty")

+ var ErrAccountEmptyPassword = errors.New("principal password is empty")

+ var ErrAccountEmptyResource = errors.New("principal resource is empty")

+ var ErrAccountEmptyRole = errors.New("principal role is empty")

+ var ErrAccountExistingUsername = errors.New("principal username already exists")

+ var ErrAccountExpired = errors.New("principal has expired")

+ var ErrAccountExpiredPassword = errors.New("principal password has expired")

+ var ErrAccountInvalidAuthorities = errors.New("principal authorities are invalid")

+ var ErrAccountInvalidPassphrase = errors.New("principal passphrase is invalid")

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

+ var ErrAccountInvalidRole = errors.New("principal role is invalid")

+ var ErrAccountInvalidUsername = errors.New("principal username is invalid")

+ var ErrAccountLocked = errors.New("principal is locked")

+ var ErrPasswordNumbers = errors.New("password must contain at least 2 numbers")

+ var ErrPasswordSpecialChars = errors.New("password must contain at least 2 special characters")

+ var ErrPasswordUppercaseChars = errors.New("password must contain at least 2 uppercase characters")

+ var ErrTokenEmptyClaims = errors.New("token claims is empty")

+ var ErrTokenEmptyResourcesClaim = errors.New("token resources claim is empty")

+ var ErrTokenEmptyRoleClaim = errors.New("token role claim is empty")

+ var ErrTokenEmptyUsernameClaim = errors.New("token username claim is empty")

+ var ErrTokenFailedParsing = errors.New("token failed to parse")

+ var ErrTokenInvalidResourcesClaim = errors.New("token resources claim is invalid")

+ var ErrTokenInvalidRoleClaim = errors.New("token role claim is invalid")

+ var ErrTokenInvalidUsernameClaim = errors.New("token username claim is invalid")

+ func ErrAuthenticationFailed(errs ...error) error

+ func ErrAuthorizationFailed(errs ...error) error

+ func ErrPasswordEncodingFailed(errs ...error) error

+ func ErrPasswordMatchingFailed(errs ...error) error

+ func ErrPasswordUpgradeEncodingValidationFailed(errs ...error) error

+ func ErrPasswordValidationFailed(errs ...error) error

+ func ErrTokenGenerationFailed(errs ...error) error

+ func ErrTokenValidationFailed(errs ...error) error

type Principal

+ NonExpired *bool

+ NonLocked *bool

+ Passphrase *string

+ Resources *[]string

v0.3.0

May 22, 2023

Changes in this version

+ const Argon2PrefixKey

+ const BcryptPrefixKey

+ const Pbkdf2PrefixKey

+ const ScryptPrefixKey

+ var ErrBcryptCostNotAllowed = errors.New("bcryptCost not allowed")

+ var ErrEncodedPasswordIsEmpty = errors.New("encodedPassword cannot be empty")

+ var ErrEncodedPasswordNotAllowed = errors.New("encodedPassword format not allowed")

+ var ErrFailedAuthentication = errors.New("incorrect principal username or password")

+ var ErrFailedAuthorization = errors.New("invalid authorities")

+ var ErrHashFuncIsNil = errors.New("hashFunc cannot be nil")

+ var ErrPasswordEncoderNotFound = errors.New("password encoder not found")

+ var ErrRawPasswordIsEmpty = errors.New("rawPassword cannot be empty")

+ var ErrSaltIsEmpty = errors.New("salt cannot be empty")

+ var ErrSaltIsNil = errors.New("salt cannot be nil")

+ var ErrTokenInvalid = errors.New("invalid token")

+ var SupportedDecoders = map[string]PasswordEncoder

+ func Argon2Decode(encodedPassword string) (*string, *int, *int, *int, *int, *[]byte, *[]byte, error)

+ func Argon2Encode(rawPassword string, salt []byte, iterations int, memory int, threads int, ...) (*string, error)

+ func GenerateSalt(saltSize int) ([]byte, error)

+ func Pbkdf2Decode(encodedPassword string) (*string, *int, *[]byte, *[]byte, error)

+ func Pbkdf2Encode(rawPassword string, salt []byte, iterations int, keyLength int, fn HashFunc) (*string, error)

+ func ScryptDecode(encodedPassword string) (*string, *int, *int, *int, *[]byte, *[]byte, error)

+ func ScryptEncode(rawPassword string, salt []byte, N int, r int, p int, keyLen int) (*string, error)

+ type Argon2PasswordEncoder struct

+ func NewArgon2PasswordEncoder(options ...Argon2PasswordEncoderOption) *Argon2PasswordEncoder

+ func (encoder *Argon2PasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (encoder *Argon2PasswordEncoder) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (encoder *Argon2PasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type Argon2PasswordEncoderOption func(encoder *Argon2PasswordEncoder)

+ func WithArgon2Iterations(iterations int) Argon2PasswordEncoderOption

+ func WithArgon2KeyLength(keyLength int) Argon2PasswordEncoderOption

+ func WithArgon2Memory(memory int) Argon2PasswordEncoderOption

+ func WithArgon2SaltLength(saltLength int) Argon2PasswordEncoderOption

+ func WithArgon2Threads(threads int) Argon2PasswordEncoderOption

+ type AuthenticationEndpoint interface

+ Authenticate func(ctx *gin.Context)

+ type AuthenticationService interface

+ Authenticate func(ctx context.Context, principal *Principal) error

+ type AuthorizationDelegate interface

+ Authorize func(ctx context.Context, principal *Principal) error

+ type AuthorizationFilter interface

+ Authorize func(ctx *gin.Context)

+ type AuthorizationService interface

+ Authorize func(ctx context.Context, tokenString string) (*Principal, error)

+ type BcryptPasswordEncoder struct

+ func NewBcryptPasswordEncoder(options ...BcryptPasswordEncoderOption) *BcryptPasswordEncoder

+ func (encoder *BcryptPasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (encoder *BcryptPasswordEncoder) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (encoder *BcryptPasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type BcryptPasswordEncoderOption func(encoder *BcryptPasswordEncoder)

+ func WithBcryptCost(cost int) BcryptPasswordEncoderOption

+ type DefaultAuthenticationDelegate struct

+ func NewDefaultAuthenticationDelegate(passwordEncoder PasswordEncoder, principalManager PrincipalManager) *DefaultAuthenticationDelegate

+ func (delegate *DefaultAuthenticationDelegate) Authenticate(ctx context.Context, principal *Principal) error

+ type DefaultAuthenticationEndpoint struct

+ func NewDefaultAuthenticationEndpoint(authenticationService AuthenticationService) *DefaultAuthenticationEndpoint

+ func (endpoint *DefaultAuthenticationEndpoint) Authenticate(ctx *gin.Context)

+ type DefaultAuthenticationService struct

+ func NewDefaultAuthenticationService(tokenManager TokenManager, authenticationDelegate AuthenticationService) *DefaultAuthenticationService

+ func (service *DefaultAuthenticationService) Authenticate(ctx context.Context, principal *Principal) error

+ type DefaultAuthorizationDelegate struct

+ func NewDefaultAuthorizationDelegate(principalManager PrincipalManager) *DefaultAuthorizationDelegate

+ func (delegate *DefaultAuthorizationDelegate) Authorize(ctx context.Context, principal *Principal) error

+ type DefaultAuthorizationFilter struct

+ func NewDefaultAuthorizationFilter(authorizationService AuthorizationService) *DefaultAuthorizationFilter

+ func (filter *DefaultAuthorizationFilter) Authorize(ctx *gin.Context)

+ type DefaultAuthorizationService struct

+ func NewDefaultAuthorizationService(tokenManager TokenManager, authorizationDelegate AuthorizationDelegate) *DefaultAuthorizationService

+ func (service *DefaultAuthorizationService) Authorize(ctx context.Context, tokenString string) (*Principal, error)

+ type DefaultClaims struct

+ type DefaultPasswordGenerator struct

+ func NewDefaultPasswordGenerator(options ...DefaultPasswordGeneratorOption) *DefaultPasswordGenerator

+ func (generator *DefaultPasswordGenerator) Generate() string

+ func (generator *DefaultPasswordGenerator) Validate(rawPassword string) error

+ type DefaultPasswordGeneratorOption func(generator *DefaultPasswordGenerator)

+ func WithMinNum(minNum int) DefaultPasswordGeneratorOption

+ func WithMinSpecialChar(minSpecialChar int) DefaultPasswordGeneratorOption

+ func WithMinUpperCase(minUpperCase int) DefaultPasswordGeneratorOption

+ func WithPasswordLength(length int) DefaultPasswordGeneratorOption

+ type DefaultPasswordManager struct

+ func NewDefaultPasswordManager(passwordEncoder PasswordEncoder, passwordGenerator PasswordGenerator) *DefaultPasswordManager

+ func (manager *DefaultPasswordManager) Encode(rawPassword string) (*string, error)

+ func (manager *DefaultPasswordManager) Generate() string

+ func (manager *DefaultPasswordManager) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (manager *DefaultPasswordManager) UpgradeEncoding(encodedPassword string) (*bool, error)

+ func (manager *DefaultPasswordManager) Validate(rawPassword string) error

+ type DelegatingPasswordEncoder struct

+ func NewDelegatingPasswordEncoder(encoder PasswordEncoder, options ...DelegatingPasswordEncoderOption) *DelegatingPasswordEncoder

+ func (delegate *DelegatingPasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (delegate *DelegatingPasswordEncoder) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (delegate *DelegatingPasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type DelegatingPasswordEncoderOption func(encoder *DelegatingPasswordEncoder)

+ func WithSupportedDecoders(decoders map[string]PasswordEncoder) DelegatingPasswordEncoderOption

+ type GrantedAuthority struct

+ Name *string

+ Resources []string

+ type HashFunc func() hash.Hash

+ type InMemoryPrincipalManager struct

+ func NewInMemoryPrincipalManager(passwordManager PasswordManager) *InMemoryPrincipalManager

+ func (manager *InMemoryPrincipalManager) ChangePassword(ctx context.Context, username string, password string) error

+ func (manager *InMemoryPrincipalManager) Create(ctx context.Context, principal *Principal) error

+ func (manager *InMemoryPrincipalManager) Delete(_ context.Context, username string) error

+ func (manager *InMemoryPrincipalManager) Exists(_ context.Context, username string) error

+ func (manager *InMemoryPrincipalManager) Find(_ context.Context, username string) (*Principal, error)

+ func (manager *InMemoryPrincipalManager) Update(ctx context.Context, principal *Principal) error

+ func (manager *InMemoryPrincipalManager) VerifyResource(ctx context.Context, username string, resource string) error

+ type JwtTokenManager struct

+ func NewJwtTokenManager(secretKey any, options ...JwtTokenManagerOption) *JwtTokenManager

+ func (manager *JwtTokenManager) Generate(principal *Principal) (*string, error)

+ func (manager *JwtTokenManager) Validate(tokenString string) (*Principal, error)

+ type JwtTokenManagerOption func(tokenManager *JwtTokenManager)

+ func WithIssuer(issuer string) JwtTokenManagerOption

+ func WithSigningMethod(signingMethod jwt.SigningMethod) JwtTokenManagerOption

+ func WithTimeout(timeout time.Duration) JwtTokenManagerOption

+ type MockAuthenticationEndpoint struct

+ func NewMockAuthenticationEndpoint(ctrl *gomock.Controller) *MockAuthenticationEndpoint

+ func (m *MockAuthenticationEndpoint) Authenticate(ctx *gin.Context)

+ func (m *MockAuthenticationEndpoint) EXPECT() *MockAuthenticationEndpointMockRecorder

+ type MockAuthenticationEndpointMockRecorder struct

+ func (mr *MockAuthenticationEndpointMockRecorder) Authenticate(ctx interface{}) *gomock.Call

+ type MockAuthenticationService struct

+ func NewMockAuthenticationService(ctrl *gomock.Controller) *MockAuthenticationService

+ func (m *MockAuthenticationService) Authenticate(ctx context.Context, principal *Principal) error

+ func (m *MockAuthenticationService) EXPECT() *MockAuthenticationServiceMockRecorder

+ type MockAuthenticationServiceMockRecorder struct

+ func (mr *MockAuthenticationServiceMockRecorder) Authenticate(ctx, principal interface{}) *gomock.Call

+ type MockAuthorizationDelegate struct

+ func NewMockAuthorizationDelegate(ctrl *gomock.Controller) *MockAuthorizationDelegate

+ func (m *MockAuthorizationDelegate) Authorize(ctx context.Context, principal *Principal) error

+ func (m *MockAuthorizationDelegate) EXPECT() *MockAuthorizationDelegateMockRecorder

+ type MockAuthorizationDelegateMockRecorder struct

+ func (mr *MockAuthorizationDelegateMockRecorder) Authorize(ctx, principal interface{}) *gomock.Call

+ type MockAuthorizationFilter struct

+ func NewMockAuthorizationFilter(ctrl *gomock.Controller) *MockAuthorizationFilter

+ func (m *MockAuthorizationFilter) Authorize(ctx *gin.Context)

+ func (m *MockAuthorizationFilter) EXPECT() *MockAuthorizationFilterMockRecorder

+ type MockAuthorizationFilterMockRecorder struct

+ func (mr *MockAuthorizationFilterMockRecorder) Authorize(ctx interface{}) *gomock.Call

+ type MockAuthorizationService struct

+ func NewMockAuthorizationService(ctrl *gomock.Controller) *MockAuthorizationService

+ func (m *MockAuthorizationService) Authorize(ctx context.Context, tokenString string) (*Principal, error)

+ func (m *MockAuthorizationService) EXPECT() *MockAuthorizationServiceMockRecorder

+ type MockAuthorizationServiceMockRecorder struct

+ func (mr *MockAuthorizationServiceMockRecorder) Authorize(ctx, tokenString interface{}) *gomock.Call

+ type MockPasswordEncoder struct

+ func NewMockPasswordEncoder(ctrl *gomock.Controller) *MockPasswordEncoder

+ func (m *MockPasswordEncoder) EXPECT() *MockPasswordEncoderMockRecorder

+ func (m *MockPasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (m *MockPasswordEncoder) Matches(encodedPassword, rawPassword string) (*bool, error)

+ func (m *MockPasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type MockPasswordEncoderMockRecorder struct

+ func (mr *MockPasswordEncoderMockRecorder) Encode(rawPassword interface{}) *gomock.Call

+ func (mr *MockPasswordEncoderMockRecorder) Matches(encodedPassword, rawPassword interface{}) *gomock.Call

+ func (mr *MockPasswordEncoderMockRecorder) UpgradeEncoding(encodedPassword interface{}) *gomock.Call

+ type MockPasswordGenerator struct

+ func NewMockPasswordGenerator(ctrl *gomock.Controller) *MockPasswordGenerator

+ func (m *MockPasswordGenerator) EXPECT() *MockPasswordGeneratorMockRecorder

+ func (m *MockPasswordGenerator) Generate() string

+ func (m *MockPasswordGenerator) Validate(rawPassword string) error

+ type MockPasswordGeneratorMockRecorder struct

+ func (mr *MockPasswordGeneratorMockRecorder) Generate() *gomock.Call

+ func (mr *MockPasswordGeneratorMockRecorder) Validate(rawPassword interface{}) *gomock.Call

+ type MockPasswordManager struct

+ func NewMockPasswordManager(ctrl *gomock.Controller) *MockPasswordManager

+ func (m *MockPasswordManager) EXPECT() *MockPasswordManagerMockRecorder

+ func (m *MockPasswordManager) Encode(rawPassword string) (*string, error)

+ func (m *MockPasswordManager) Generate() string

+ func (m *MockPasswordManager) Matches(encodedPassword, rawPassword string) (*bool, error)

+ func (m *MockPasswordManager) UpgradeEncoding(encodedPassword string) (*bool, error)

+ func (m *MockPasswordManager) Validate(rawPassword string) error

+ type MockPasswordManagerMockRecorder struct

+ func (mr *MockPasswordManagerMockRecorder) Encode(rawPassword interface{}) *gomock.Call

+ func (mr *MockPasswordManagerMockRecorder) Generate() *gomock.Call

+ func (mr *MockPasswordManagerMockRecorder) Matches(encodedPassword, rawPassword interface{}) *gomock.Call

+ func (mr *MockPasswordManagerMockRecorder) UpgradeEncoding(encodedPassword interface{}) *gomock.Call

+ func (mr *MockPasswordManagerMockRecorder) Validate(rawPassword interface{}) *gomock.Call

+ type MockPrincipalManager struct

+ func NewMockPrincipalManager(ctrl *gomock.Controller) *MockPrincipalManager

+ func (m *MockPrincipalManager) ChangePassword(ctx context.Context, username, password string) error

+ func (m *MockPrincipalManager) Create(ctx context.Context, principal *Principal) error

+ func (m *MockPrincipalManager) Delete(ctx context.Context, username string) error

+ func (m *MockPrincipalManager) EXPECT() *MockPrincipalManagerMockRecorder

+ func (m *MockPrincipalManager) Exists(ctx context.Context, username string) error

+ func (m *MockPrincipalManager) Find(ctx context.Context, username string) (*Principal, error)

+ func (m *MockPrincipalManager) Update(ctx context.Context, principal *Principal) error

+ func (m *MockPrincipalManager) VerifyResource(ctx context.Context, username, resource string) error

+ type MockPrincipalManagerMockRecorder struct

+ func (mr *MockPrincipalManagerMockRecorder) ChangePassword(ctx, username, password interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) Create(ctx, principal interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) Delete(ctx, username interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) Exists(ctx, username interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) Find(ctx, username interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) Update(ctx, principal interface{}) *gomock.Call

+ func (mr *MockPrincipalManagerMockRecorder) VerifyResource(ctx, username, resource interface{}) *gomock.Call

+ type MockTokenManager struct

+ func NewMockTokenManager(ctrl *gomock.Controller) *MockTokenManager

+ func (m *MockTokenManager) EXPECT() *MockTokenManagerMockRecorder

+ func (m *MockTokenManager) Generate(principal *Principal) (*string, error)

+ func (m *MockTokenManager) Validate(tokenString string) (*Principal, error)

+ type MockTokenManagerMockRecorder struct

+ func (mr *MockTokenManagerMockRecorder) Generate(principal interface{}) *gomock.Call

+ func (mr *MockTokenManagerMockRecorder) Validate(tokenString interface{}) *gomock.Call

+ type PasswordEncoder interface

+ Encode func(rawPassword string) (*string, error)

+ Matches func(encodedPassword string, rawPassword string) (*bool, error)

+ UpgradeEncoding func(encodedPassword string) (*bool, error)

+ type PasswordGenerator interface

+ Generate func() string

+ Validate func(rawPassword string) error

+ type PasswordManager interface

+ type Pbkdf2PasswordEncoder struct

+ func NewPbkdf2PasswordEncoder(options ...Pbkdf2PasswordEncoderOption) *Pbkdf2PasswordEncoder

+ func (encoder *Pbkdf2PasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (encoder *Pbkdf2PasswordEncoder) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (encoder *Pbkdf2PasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type Pbkdf2PasswordEncoderOption func(encoder *Pbkdf2PasswordEncoder)

+ func WithHashFunc(hashFunc HashFunc) Pbkdf2PasswordEncoderOption

+ func WithPbkdf2Iterations(iterations int) Pbkdf2PasswordEncoderOption

+ func WithPbkdf2KeyLength(keyLength int) Pbkdf2PasswordEncoderOption

+ func WithPbkdf2SaltLength(saltLength int) Pbkdf2PasswordEncoderOption

+ type Principal struct

+ AccountNonExpired *bool

+ AccountNonLocked *bool

+ Authorities []GrantedAuthority

+ Enabled *bool

+ Password *string

+ PasswordNonExpired *bool

+ Role *string

+ SignUpDone *bool

+ Token *string

+ Username *string

+ type PrincipalManager interface

+ ChangePassword func(ctx context.Context, username string, password string) error

+ Create func(ctx context.Context, principal *Principal) error

+ Delete func(ctx context.Context, username string) error

+ Exists func(ctx context.Context, username string) error

+ Find func(ctx context.Context, username string) (*Principal, error)

+ Update func(ctx context.Context, principal *Principal) error

+ VerifyResource func(ctx context.Context, username string, resource string) error

+ type ResourceCtxKey struct

+ type RoleCtxKey struct

+ type ScryptPasswordEncoder struct

+ N int

+ func NewScryptPasswordEncoder(options ...ScryptPasswordEncoderOption) *ScryptPasswordEncoder

+ func (encoder *ScryptPasswordEncoder) Encode(rawPassword string) (*string, error)

+ func (encoder *ScryptPasswordEncoder) Matches(encodedPassword string, rawPassword string) (*bool, error)

+ func (encoder *ScryptPasswordEncoder) UpgradeEncoding(encodedPassword string) (*bool, error)

+ type ScryptPasswordEncoderOption func(encoder *ScryptPasswordEncoder)

+ func WithScryptKeyLength(keyLength int) ScryptPasswordEncoderOption

+ func WithScryptN(N int) ScryptPasswordEncoderOption

+ func WithScryptP(p int) ScryptPasswordEncoderOption

+ func WithScryptR(r int) ScryptPasswordEncoderOption

+ func WithScryptSaltLength(saltLength int) ScryptPasswordEncoderOption

+ type TokenManager interface

+ Generate func(principal *Principal) (*string, error)

+ Validate func(tokenString string) (*Principal, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL