mirror of https://github.com/gofiber/fiber.git
141 lines
3.4 KiB
Go
141 lines
3.4 KiB
Go
// Special thanks to Echo: https://github.com/labstack/echo/blob/master/middleware/key_auth.go
|
|
package keyauth
|
|
|
|
import (
|
|
"errors"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"github.com/gofiber/fiber/v3"
|
|
)
|
|
|
|
// The contextKey type is unexported to prevent collisions with context keys defined in
|
|
// other packages.
|
|
type contextKey int
|
|
|
|
// The keys for the values in context
|
|
const (
|
|
tokenKey contextKey = 0
|
|
)
|
|
|
|
// When there is no request of the key thrown ErrMissingOrMalformedAPIKey
|
|
var ErrMissingOrMalformedAPIKey = errors.New("missing or malformed API Key")
|
|
|
|
const (
|
|
query = "query"
|
|
form = "form"
|
|
param = "param"
|
|
cookie = "cookie"
|
|
)
|
|
|
|
// New creates a new middleware handler
|
|
func New(config ...Config) fiber.Handler {
|
|
// Init config
|
|
cfg := configDefault(config...)
|
|
|
|
// Initialize
|
|
parts := strings.Split(cfg.KeyLookup, ":")
|
|
extractor := keyFromHeader(parts[1], cfg.AuthScheme)
|
|
switch parts[0] {
|
|
case query:
|
|
extractor = keyFromQuery(parts[1])
|
|
case form:
|
|
extractor = keyFromForm(parts[1])
|
|
case param:
|
|
extractor = keyFromParam(parts[1])
|
|
case cookie:
|
|
extractor = keyFromCookie(parts[1])
|
|
}
|
|
|
|
// Return middleware handler
|
|
return func(c fiber.Ctx) error {
|
|
// Filter request to skip middleware
|
|
if cfg.Next != nil && cfg.Next(c) {
|
|
return c.Next()
|
|
}
|
|
|
|
// Extract and verify key
|
|
key, err := extractor(c)
|
|
if err != nil {
|
|
return cfg.ErrorHandler(c, err)
|
|
}
|
|
|
|
valid, err := cfg.Validator(c, key)
|
|
|
|
if err == nil && valid {
|
|
c.Locals(tokenKey, key)
|
|
return cfg.SuccessHandler(c)
|
|
}
|
|
return cfg.ErrorHandler(c, err)
|
|
}
|
|
}
|
|
|
|
// TokenFromContext returns the bearer token from the request context.
|
|
// returns an empty string if the token does not exist
|
|
func TokenFromContext(c fiber.Ctx) string {
|
|
token, ok := c.Locals(tokenKey).(string)
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return token
|
|
}
|
|
|
|
// keyFromHeader returns a function that extracts api key from the request header.
|
|
func keyFromHeader(header, authScheme string) func(c fiber.Ctx) (string, error) {
|
|
return func(c fiber.Ctx) (string, error) {
|
|
auth := c.Get(header)
|
|
l := len(authScheme)
|
|
if len(auth) > 0 && l == 0 {
|
|
return auth, nil
|
|
}
|
|
if len(auth) > l+1 && auth[:l] == authScheme {
|
|
return auth[l+1:], nil
|
|
}
|
|
return "", ErrMissingOrMalformedAPIKey
|
|
}
|
|
}
|
|
|
|
// keyFromQuery returns a function that extracts api key from the query string.
|
|
func keyFromQuery(param string) func(c fiber.Ctx) (string, error) {
|
|
return func(c fiber.Ctx) (string, error) {
|
|
key := fiber.Query[string](c, param)
|
|
if key == "" {
|
|
return "", ErrMissingOrMalformedAPIKey
|
|
}
|
|
return key, nil
|
|
}
|
|
}
|
|
|
|
// keyFromForm returns a function that extracts api key from the form.
|
|
func keyFromForm(param string) func(c fiber.Ctx) (string, error) {
|
|
return func(c fiber.Ctx) (string, error) {
|
|
key := c.FormValue(param)
|
|
if key == "" {
|
|
return "", ErrMissingOrMalformedAPIKey
|
|
}
|
|
return key, nil
|
|
}
|
|
}
|
|
|
|
// keyFromParam returns a function that extracts api key from the url param string.
|
|
func keyFromParam(param string) func(c fiber.Ctx) (string, error) {
|
|
return func(c fiber.Ctx) (string, error) {
|
|
key, err := url.PathUnescape(c.Params(param))
|
|
if err != nil {
|
|
return "", ErrMissingOrMalformedAPIKey
|
|
}
|
|
return key, nil
|
|
}
|
|
}
|
|
|
|
// keyFromCookie returns a function that extracts api key from the named cookie.
|
|
func keyFromCookie(name string) func(c fiber.Ctx) (string, error) {
|
|
return func(c fiber.Ctx) (string, error) {
|
|
key := c.Cookies(name)
|
|
if key == "" {
|
|
return "", ErrMissingOrMalformedAPIKey
|
|
}
|
|
return key, nil
|
|
}
|
|
}
|