authn

type Claims ¶

type Claims struct {
	Role string `json:"role"`
	Id   string `json:"id"`
	jwt.RegisteredClaims
	RawClaims string `json:"-"`
	// contains filtered or unexported fields
}

type Error ¶ added in v0.11.0

type Error struct {
	Status int
	// Code is PostgREST's code for the refusal (PGRST301, ...), "" for none
	Code    string
	Message string
	// Challenge is the WWW-Authenticate value of a 401, "" for none
	Challenge string
	// Details are reported when errors are verbose, else the cause's message
	Details string
	// Err is the cause
	Err error
}

Error is a refusal the middleware decides itself, before the database has a say: a missing or invalid token, an unknown database, a pool that hands out no connection. The errors the database raises while the request is prepared (the role switch) travel as they are, and get the status of every other database error.

func (e *Error) Error() string

func (e *Error) Unwrap() error

type ErrorWriter ¶ added in v0.11.0

type ErrorWriter func(w http.ResponseWriter, err error, authenticated bool) (int, error)

ErrorWriter writes the response of a request the middleware refuses. authenticated says whether the request runs as a role other than the anonymous one, which decides the status of an insufficient privilege.

type GetDatabaseNameFn ¶

type GetDatabaseNameFn func(ctx context.Context, r heligo.Request) string

type JWTConfig ¶ added in v0.11.0

type JWTConfig struct {
	Secret         string // PostgREST's jwt-secret: a passphrase, a JWK or a JWK set
	SecretIsBase64 bool   // jwt-secret-is-base64
	Aud            string // jwt-aud, "" for any audience
	RoleClaimKey   string // jwt-role-claim-key, "" for "$.role"
	Keys           string // the key catalog, verifying instead of Secret when set
}

JWTConfig is the JWT part of the server configuration.

type JWTError ¶ added in v0.11.0

type JWTError struct {
	Code    string
	Message string
	Details string
}

JWTError is a token that failed verification: PostgREST's PGRST301 (the token cannot be decoded or no key verifies it) and PGRST303 (its claims are invalid), with the same messages (Error.hs, ErrorBody JwtError). Both are a 401 for an invalid token, the case for which PostgREST answers with WWW-Authenticate: Bearer error="invalid_token", error_description=<Message>. Other authentication errors, such as a missing anonymous role, are not JWTErrors.

func (e *JWTError) Error() string

type JWTVerifier ¶ added in v0.11.0

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

JWTVerifier verifies bearer tokens and maps their claims, as PostgREST's Auth/Jwt.hs does.

func NewJWTVerifier(cfg JWTConfig) (*JWTVerifier, error)

func (v *JWTVerifier) RoleClaimKey() *RoleClaimKey

func (v *JWTVerifier) SigningSecret() string

func (v *JWTVerifier) SignsWithCatalogKey() bool

type MiddlewareConfig ¶

type MiddlewareConfig interface {
	GetDatabase(context.Context, string) (*database.Database, error)
	JWTVerifier() *JWTVerifier
	AllowAnon() bool
	AnonRole() string
	RequestMaxBytes() int64
	SessionManager() *SessionManager
	GetLogger() *logging.Logger
	// AuthErrorWriter writes the refusals of the middleware the way the API
	// writes its errors; nil writes a bare {"error": ...}
	AuthErrorWriter() ErrorWriter
}

type RoleClaimKey ¶ added in v0.11.0

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

RoleClaimKey locates the role in the JWT claims, PostgREST's jwt-role-claim-key. PostgREST 16 reads it as a JSONPath query (RFC 9535, Config/JSPath.hs, with the aeson-jsonpath library); smoothdb reads the subset that the identity providers need and PostgREST documents and tests: $, .name, ['name'] and ["name"], [index], and one filter on the current element, [?@ == "text"], [?@ != "text"] or [?search(@, "regex")]. A key with any other JSONPath construct is refused at startup, naming it, so that the divergence from PostgREST is never a different role at runtime. A key that does not start with "$" is read with the JSPath DSL of PostgREST 15 and earlier (Config/DeprecatedJSPath.hs), which 16.4 still accepts with a warning.

func ParseRoleClaimKey(s string) (*RoleClaimKey, error)

func (k *RoleClaimKey) Deprecated() bool

func (k *RoleClaimKey) String() string

type Session ¶

type Session struct {
	Claims     *Claims
	LastUsedAt time.Time
	Db         *database.Database
	DbConn     *database.DbPoolConn
	// contains filtered or unexported fields
}

A Session for SmoothDB is the way to cache information about a user and his connection to a database

type SessionList ¶

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

type SessionManager ¶

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

SessionManager manages user sessions and monitors them efficiently. When disabled, it simply returns Sessions without managing or monitoring.

func NewSessionManager(logger *logging.Logger, enabled bool, shutdown chan struct{}) *SessionManager

func (sm *SessionManager) SetMaxSessions(n int)

func (sm *SessionManager) Statistics() SessionStatistics

type SessionStatistics ¶

type SessionStatistics struct {
	Count int
	InUse int
	Users int
}