auth

Documentation

Overview

Package auth handles auth

Index

• Variables
• func Authenticate(conf AuthOptions) echo.MiddlewareFunc
• func Reauthenticate(conf AuthOptions, validator tokens.Validator) func(c echo.Context) (string, error)
• type AuthOption
  • func WithAudience(audience string) AuthOption
  • func WithAuthOptions(opts AuthOptions) AuthOption
  • func WithBeforeFunc(before middleware.BeforeFunc) AuthOption
  • func WithContext(ctx context.Context) AuthOption
  • func WithDBClient(client *ent.Client) AuthOption
  • func WithIssuer(issuer string) AuthOption
  • func WithJWKSEndpoint(url string) AuthOption
  • func WithMinRefreshInterval(interval time.Duration) AuthOption
  • func WithReauthenticator(reauth Reauthenticator) AuthOption
  • func WithSkipperFunc(skipper middleware.Skipper) AuthOption
  • func WithValidator(validator tokens.Validator) AuthOption
• type AuthOptions
  • func NewAuthOptions(opts ...AuthOption) (conf AuthOptions)
  • func (conf *AuthOptions) Validator() (tokens.Validator, error)
• type Reauthenticator

Variables

var (
	// ErrNoClaims is returned when no claims are found on the request context
	ErrNoClaims = errors.New("no claims found on the request context")

	// ErrNoUserInfo is returned when no user info is found on the request context
	ErrNoUserInfo = errors.New("no user info found on the request context")

	// ErrNoAuthUser is returned when no authenticated user is found on the request context
	ErrNoAuthUser = errors.New("could not identify authenticated user in request")

	// ErrUnverifiedUser is returned when the user is not verified
	ErrUnverifiedUser = errors.New("user is not verified")

	// ErrParseBearer is returned when the bearer token could not be parsed from the authorization header
	ErrParseBearer = errors.New("could not parse bearer token from authorization header")

	// ErrNoAuthorization is returned when no authorization header is found in the request
	ErrNoAuthorization = errors.New("no authorization header in request")

	// ErrNoRequest is returned when no request is found on the context
	ErrNoRequest = errors.New("no request found on the context")

	// ErrNoRefreshToken is returned when no refresh token is found on the request
	ErrNoRefreshToken = errors.New("no refresh token available on request")

	// ErrRefreshDisabled is returned when re-authentication with refresh tokens is disabled
	ErrRefreshDisabled = errors.New("re-authentication with refresh tokens disabled")

	// ErrUnableToConstructValidator is returned when the validator cannot be constructed
	ErrUnableToConstructValidator = errors.New("unable to construct validator")

	// ErrPasswordTooWeak is returned when the password is too weak
	ErrPasswordTooWeak = errors.New("password is too weak: use a combination of upper and lower case letters, numbers, and special characters")
)

var DefaultAuthOptions = AuthOptions{
	KeysURL:            "http://localhost:17608/.well-known/jwks.json",
	Audience:           "http://localhost:17608",
	Issuer:             "http://localhost:17608",
	MinRefreshInterval: 5 * time.Minute,
	Skipper:            middleware.DefaultSkipper,
}

var SessionSkipperFunc = func(c echo.Context) bool {
	return auth.GetAuthTypeFromEchoContext(c) != auth.JWTAuthentication
}

SessionSkipperFunc is the function that determines if the session check should be skipped due to the request being a PAT or API Token auth request

Functions

func Authenticate

func Authenticate(conf AuthOptions) echo.MiddlewareFunc

Authenticate is a middleware function that is used to authenticate requests - it is not applied to all routes so be cognizant of that

func Reauthenticate

func Reauthenticate(conf AuthOptions, validator tokens.Validator) func(c echo.Context) (string, error)

Reauthenticate is a middleware helper that can use refresh tokens in the echo context to obtain a new access token. If it is unable to obtain a new valid access token, then an error is returned and processing should stop.

Types

type AuthOption

type AuthOption func(opts *AuthOptions)

AuthOption allows users to optionally supply configuration to the Authorization middleware.

func WithAudience

func WithAudience(audience string) AuthOption

WithAudience allows the user to specify an alternative audience.

func WithAuthOptions

func WithAuthOptions(opts AuthOptions) AuthOption

WithAuthOptions allows the user to update the default auth options with an auth options struct to set many options values at once. Zero values are ignored, so if using this option, the defaults will still be preserved if not set on the input.

func WithBeforeFunc

func WithBeforeFunc(before middleware.BeforeFunc) AuthOption

WithBeforeFunc allows the user to specify a function to happen before the auth middleware

func WithContext

func WithContext(ctx context.Context) AuthOption

WithContext allows the user to specify an external, cancelable context to control the background refresh behavior of the JWKS cache.

func WithDBClient

func WithDBClient(client *ent.Client) AuthOption

WithDBClient is a function that returns an AuthOption function which sets the DBClient field of AuthOptions. The DBClient field is used to specify the database client to be to check authentication with personal access tokens.

func WithIssuer

func WithIssuer(issuer string) AuthOption

WithIssuer allows the user to specify an alternative issuer.

func WithJWKSEndpoint

func WithJWKSEndpoint(url string) AuthOption

WithJWKSEndpoint allows the user to specify an alternative endpoint to fetch the JWKS public keys from. This is useful for testing or for different environments.

func WithMinRefreshInterval

func WithMinRefreshInterval(interval time.Duration) AuthOption

WithMinRefreshInterval allows the user to specify an alternative minimum duration between cache refreshes to control refresh behavior for the JWKS public keys.

func WithReauthenticator

func WithReauthenticator(reauth Reauthenticator) AuthOption

WithReauthenticator allows the user to specify a reauthenticator to the auth middleware.

func WithSkipperFunc

func WithSkipperFunc(skipper middleware.Skipper) AuthOption

WithSkipperFunc allows the user to specify a skipper function for the middleware

func WithValidator

func WithValidator(validator tokens.Validator) AuthOption

WithValidator allows the user to specify an alternative validator to the auth middleware. This is particularly useful for testing authentication.

type AuthOptions

type AuthOptions struct {
	// KeysURL endpoint to the JWKS public keys on the datum server
	KeysURL string `default:"http://localhost:17608/.well-known/jwks.json"`
	// Audience to verify on tokens
	Audience string `default:"http://localhost:17608"`
	// Issuer to verify on tokens
	Issuer string `default:"http://localhost:17608"`
	// MinRefreshInterval to cache the JWKS public keys
	MinRefreshInterval time.Duration `default:"5m"`
	// Context to control the lifecycle of the background fetch routine
	Context context.Context

	// Skipper defines a function to skip middleware
	Skipper middleware.Skipper
	// BeforeFunc  defines a function which is executed just before the middleware
	BeforeFunc middleware.BeforeFunc

	// Used to check other auth types like personal access tokens
	DBClient *ent.Client
	// contains filtered or unexported fields
}

AuthOptions is constructed from variadic AuthOption arguments with reasonable defaults.

func NewAuthOptions

func NewAuthOptions(opts ...AuthOption) (conf AuthOptions)

NewAuthOptions creates an AuthOptions object with reasonable defaults and any user supplied input from the AuthOption variadic arguments.

func (*AuthOptions) Validator

func (conf *AuthOptions) Validator() (tokens.Validator, error)

Validator returns the user supplied validator or constructs a new JWKS Cache Validator from the supplied options. If the options are invalid or the validator cannot be created an error is returned

type Reauthenticator

type Reauthenticator interface {
	Refresh(context.Context, *api.RefreshRequest) (*api.LoginReply, error)
}

Reauthenticator generates new access and refresh pair given a valid refresh token.