passwd

type AccountLockingPostProcessor struct {
	// contains filtered or unexported fields
}

type AccountStatusChecker struct {
	// contains filtered or unexported fields
}

type AccountStatusPostProcessor struct {
	// contains filtered or unexported fields
}

type AdditionalDetailsPostProcessor struct{}

type AuthenticationDecisionMaker interface {
	// Decide makes decision on whether the Authenticator should approve the auth request.
	// the returned error indicate the reason of rejection. returns nil when approved
	// 	 - The security.Authentication is nil when credentials has not been validated (pre check)
	// 	 - The security.Authentication is non-nil when credentials has been validated (post check).
	//     The non-nil value is the proposed authentication to be returned by Authenticator
	//
	// If any of input parameters are mutable, AuthenticationDecisionMaker is allowed to change it
	Decide(context.Context, security.Candidate, security.Account, security.Authentication) error
}

type AuthenticationResult struct {
	Candidate security.Candidate
	Auth      security.Authentication
	Error     error
}

type Authenticator struct {
	// contains filtered or unexported fields
}

type AuthenticatorBuilder struct {
	// contains filtered or unexported fields
}

type AuthenticatorOptions struct {
	AccountStore      security.AccountStore
	PasswordEncoder   PasswordEncoder
	OTPManager        OTPManager
	MFAEventListeners []MFAEventListenerFunc
	Checkers          []AuthenticationDecisionMaker
	PostProcessors    []PostAuthenticationProcessor
}

type AuthenticatorOptionsFunc func(*AuthenticatorOptions)

type ConditionalDecisionMaker struct {
	// contains filtered or unexported fields
}

type DecisionMakerConditionFunc func(context.Context, security.Candidate, security.Account, security.Authentication) bool

type MFAEvent int

type MFAEventListenerFunc func(event MFAEvent, otp OTP, principal interface{})

type MFAMode int

type MFAOtpRefresh struct {
	CurrentAuth UsernamePasswordAuthentication
	DetailsMap  map[string]interface{}
}

type MFAOtpVerification struct {
	CurrentAuth UsernamePasswordAuthentication
	OTP         string
	DetailsMap  map[string]interface{}
}

type MfaRefreshAuthenticator struct {
	// contains filtered or unexported fields
}

type MfaVerifyAuthenticator struct {
	// contains filtered or unexported fields
}

type OTP interface {
	ID() string
	Passcode() string
	TTL() time.Duration
	Expire() time.Time
	Attempts() uint
	Refreshes() uint
	IncrementAttempts()
	IncrementRefreshes()
	// contains filtered or unexported methods
}

type OTPManager interface {
	// New create new OTP and save it
	New() (OTP, error)

	// Get loads OTP by Domain
	Get(id string) (OTP, error)

	// Verify use Get to load OTP and check the given passcode against the loaded OTP.
	// It returns the loaded OTP regardless the verification result.
	// It returns false if it reaches maximum attempts limit. otherwise returns true
	// error parameter indicate wether the given passcode is valid. It's nil if it's valid
	Verify(id, passcode string) (loaded OTP, hasMoreChances bool, err error)

	// Refresh regenerate OTP passcode without changing secret and Domain
	// It returns the loaded or refreshed OTP regardless the verification result.
	// It returns false if it reaches maximum attempts limit. otherwise returns true
	// error parameter indicate wether the passcode is refreshed
	Refresh(id string) (refreshed OTP, hasMoreChances bool, err error)

	// Delete delete OTP by Domain
	Delete(id string) error
}

type OTPStore interface {
	Save(OTP) error
	Load(id string) (OTP, error)
	Delete(id string) error
}

type PasswordAuthConfigurer struct {
	// contains filtered or unexported fields
}

type PasswordAuthFeature struct {
	// contains filtered or unexported fields
}

type PasswordEncoder interface {
	Encode(rawPassword string) string
	Matches(raw, encoded string) bool
}

type PasswordPolicyChecker struct {
	// contains filtered or unexported fields
}

type PersistAccountPostProcessor struct {
	// contains filtered or unexported fields
}

type PostAuthenticationProcessor interface {
	// Process is invoked at the end of authentication process by the Authenticator to perform post-auth action.
	// The method is invoked regardless if the authentication is granted:
	// 	- If the authentication is granted, the AuthenticationResult.Auth is non-nil and AuthenticationResult.Error is nil
	//	- If the authentication is rejected, the AuthenticationResult.Error is non-nil and AuthenticationResult.Auth should be ignored
	//
	// If the context.Context and security.Account parameters are mutable, PostAuthenticationProcessor is allowed to change it
	// Note: PostAuthenticationProcessor typically shouldn't overwrite authentication decision (rejected or approved)
	// 		 However, it is allowed to modify result by returning different AuthenticationResult.
	//       This is useful when PostAuthenticationProcessor want to returns different error or add more details to authentication
	Process(context.Context, security.Account, AuthenticationResult) AuthenticationResult
}

type TOTP struct {
	Passcode string
	Secret   string
	TTL      time.Duration
	Expire   time.Time
}

type TOTPFactory interface {
	Generate(ttl time.Duration) (totp TOTP, err error)
	Refresh(secret string, ttl time.Duration) (totp TOTP, err error)
	Validate(totp TOTP) (valid bool, err error)
}

type UsernamePasswordAuthentication interface {
	security.Authentication
	Username() string
	IsMFAPending() bool
	OTPIdentifier() string
}

type UsernamePasswordPair struct {
	Username   string
	Password   string
	DetailsMap map[string]interface{}
	EnforceMFA MFAMode
}