🔥 Feature: Add support for multiple keys in the KeyAuth middleware

docs/api/middleware/keyauth.md

@@ -218,7 +218,7 @@ curl --header "Authorization: Bearer my-super-secret-key"  http://localhost:3000
 | Next           | `func(*fiber.Ctx) bool`                  | Next defines a function to skip this middleware when returned true.                                  | `nil`                         |
 | SuccessHandler | `fiber.Handler`                          | SuccessHandler defines a function which is executed for a valid key.                                 | `nil`                         |
 | ErrorHandler   | `fiber.ErrorHandler`                     | ErrorHandler defines a function which is executed for an invalid key.                                | `401 Invalid or expired key`  |
-| KeyLookup      | `string`                                 | KeyLookup is a string in the form of "`<source>:<name>`" that is used to extract key from the request. | "header:Authorization"        |
+| KeyLookup      | `string`                                 | KeyLookup is a string in the form of "`<source>:<name>`" that is used to extract key from the request. If multiple keys are required, they can be delimited with a pipe (`|`) character, and the first matching key will be selected. | "header:Authorization"        |
 | AuthScheme     | `string`                                 | AuthScheme to be used in the Authorization header.                                                   | "Bearer"                      |
 | Validator      | `func(*fiber.Ctx, string) (bool, error)` | Validator is a function to validate the key.                                                         | A function for key validation |
 | ContextKey     | `interface{}`                            | Context key to store the bearer token from the token into context.                                   | "token"                       |

middleware/keyauth/keyauth.go

@@ -19,23 +19,37 @@
 	cookie = "cookie"
 )
 
+type extractorFunc func(c *fiber.Ctx) (string, error)
+
 // 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])
+
+	parts := strings.Split(cfg.KeyLookup, "|")
+
+	var extractor extractorFunc
+	if len(parts) <= 1 {
+		extractor = parseSingleExtractor(cfg.KeyLookup, cfg.AuthScheme)
+	} else {
+		subExtractors := []extractorFunc{}
+		for _, keyLookup := range parts {
+			subExtractors = append(subExtractors, parseSingleExtractor(keyLookup, cfg.AuthScheme))
+		}
+		extractor = func(c *fiber.Ctx) (string, error) {
+			for _, subExtractor := range subExtractors {
+				res, err := subExtractor(c)
+				if err == nil && res != "" {
+					return res, nil
+				}
+				if !errors.Is(err, ErrMissingOrMalformedAPIKey) {
+					return "", err
+				}
+			}
+			return "", ErrMissingOrMalformedAPIKey
+		}
 	}
 
 	// Return middleware handler
@@ -61,8 +75,24 @@
 	}
 }
 
+func parseSingleExtractor(keyLookup string, authScheme string) extractorFunc {
+	parts := strings.Split(keyLookup, ":")
+	extractor := keyFromHeader(parts[1], 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 extractor
+}
+
 // keyFromHeader returns a function that extracts api key from the request header.
-func keyFromHeader(header, authScheme string) func(c *fiber.Ctx) (string, error) {
+func keyFromHeader(header, authScheme string) extractorFunc {
 	return func(c *fiber.Ctx) (string, error) {
 		auth := c.Get(header)
 		l := len(authScheme)
@@ -77,7 +107,7 @@
 }
 
 // keyFromQuery returns a function that extracts api key from the query string.
-func keyFromQuery(param string) func(c *fiber.Ctx) (string, error) {
+func keyFromQuery(param string) extractorFunc {
 	return func(c *fiber.Ctx) (string, error) {
 		key := c.Query(param)
 		if key == "" {
@@ -88,7 +118,7 @@
 }
 
 // keyFromForm returns a function that extracts api key from the form.
-func keyFromForm(param string) func(c *fiber.Ctx) (string, error) {
+func keyFromForm(param string) extractorFunc {
 	return func(c *fiber.Ctx) (string, error) {
 		key := c.FormValue(param)
 		if key == "" {
@@ -99,7 +129,7 @@
 }
 
 // keyFromParam returns a function that extracts api key from the url param string.
-func keyFromParam(param string) func(c *fiber.Ctx) (string, error) {
+func keyFromParam(param string) extractorFunc {
 	return func(c *fiber.Ctx) (string, error) {
 		key, err := url.PathUnescape(c.Params(param))
 		if err != nil {
@@ -110,7 +140,7 @@
 }
 
 // keyFromCookie returns a function that extracts api key from the named cookie.
-func keyFromCookie(name string) func(c *fiber.Ctx) (string, error) {
+func keyFromCookie(name string) extractorFunc {
 	return func(c *fiber.Ctx) (string, error) {
 		key := c.Cookies(name)
 		if key == "" {

middleware/keyauth/keyauth_test.go

@@ -131,6 +131,51 @@ func TestAuthSources(t *testing.T) {
 	}
 }
 
+func TestMultipleKeyLookup(t *testing.T) {
+	const (
+		desc    = "auth with correct key"
+		success = "Success!"
+	)
+
+	// setup the fiber endpoint
+	app := fiber.New()
+	authMiddleware := New(Config{
+		KeyLookup: "header:key|query:key",
+		Validator: func(c *fiber.Ctx, key string) (bool, error) {
+			if key == CorrectKey {
+				return true, nil
+			}
+			return false, ErrMissingOrMalformedAPIKey
+		},
+	})
+	app.Use(authMiddleware)
+	app.Get("/foo", func(c *fiber.Ctx) error {
+		return c.SendString(success)
+	})
+
+	// construct the test HTTP request
+	var req *http.Request
+	req, err := http.NewRequestWithContext(context.Background(), fiber.MethodGet, "/foo", nil)
+	utils.AssertEqual(t, err, nil)
+	q := req.URL.Query()
+	q.Add("key", CorrectKey)
+	req.URL.RawQuery = q.Encode()
+
+	res, err := app.Test(req, -1)
+
+	utils.AssertEqual(t, nil, err, desc)
+
+	// test the body of the request
+	body, err := io.ReadAll(res.Body)
+	utils.AssertEqual(t, 200, res.StatusCode, desc)
+	// body
+	utils.AssertEqual(t, nil, err, desc)
+	utils.AssertEqual(t, success, string(body), desc)
+
+	err = res.Body.Close()
+	utils.AssertEqual(t, err, nil)
+}
+
 func TestMultipleKeyAuth(t *testing.T) {
 	// setup the fiber endpoint
 	app := fiber.New()