Integer Overflow in Fiber with Cockroachdb

Integer overflow in a Fiber application that uses CockroachDB can occur when arithmetic on user-supplied values wraps around before the value is used in a database operation. For example, if an HTTP parameter intended to represent a count or an offset is parsed into an integer type without validation, and that value is later used to compute limits, slice indices, or batch sizes, the resulting computation may produce an unexpectedly small number. This can lead to logic errors such as reading too many rows, skipping pagination boundaries, or allocating insufficient buffers.

When such a wrapped integer is passed to CockroachDB, the query may still execute, but the semantics of the operation change in dangerous ways. A computed LIMIT value that underflows to a large number can cause excessive data retrieval; an offset that wraps can shift the read window unexpectedly, potentially exposing records that should be hidden. Because CockroachDB follows SQL semantics, it will process the query as written, so validation must happen in the application layer before the statement is built and executed.

In a black-box scan, middleBrick tests inputs that affect SQL construction and checks for abnormal data exposure or authentication bypass patterns. One concrete scenario: an endpoint like /api/items?limit=10000000000000000000 where the parameter is parsed into a 32-bit integer may overflow to a small number, causing the server to issue a LIMIT that returns far more rows than intended. If the endpoint also exposes sensitive fields and lacks proper authorization checks (BOLA/IDOR), the combination of overflow and missing checks increases the likelihood of unintentionally large data exposure.

Another relevant pattern is when arithmetic is used to compute array indices or batch sizes for chunked reads from CockroachDB. For instance, using an unchecked multiplication to determine a buffer size may allocate a slice that is too small, leading to out-of-bounds writes later. Because Fiber does not automatically validate numeric inputs, developers must explicitly validate ranges and use types that cannot silently wrap, such as 64-bit integers with explicit checks before use in SQL clauses.

middleBrick’s LLM/AI Security checks are not directly relevant here because this is a classical integer arithmetic issue, but the scanner’s inventory and input validation checks can surface endpoints where large or malformed numeric inputs reach the database layer. The resulting findings include severity, references to OWASP API Top 10 categories, and remediation guidance that emphasizes strict schema validation and safe arithmetic patterns before constructing queries.

To prevent integer overflow when using CockroachDB with Fiber, validate and sanitize all numeric inputs before using them in SQL statements or in calculations that affect query behavior. Use 64-bit integer types for counts, offsets, and limits, and explicitly check boundaries before building queries.

package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "strconv"

    "github.com/gofiber/fiber/v2"
    "github.com/jackc/pgx/v5/pgxpool"
)

// Safe parsing and validation for limit/offset parameters.
func parsePaginationParams(c *fiber.Ctx) (limit, offset int64, err error) {
    rawLimit := c.Query("limit", "100")
    rawOffset := c.Query("offset", "0")

    l, err := strconv.ParseInt(rawLimit, 10, 64)
    if err != nil || l < 0 || l > 10000 {
        return 0, 0 errors.New("limit must be an integer between 0 and 10000")
    }
    o, err := strconv.ParseInt(rawOffset, 10, 64)
    if err != nil || o < 0 {
        return 0, 0 errors.New("offset must be a non-negative integer")
    }
    return l, o, nil
}

// Example handler using CockroachDB with validated pagination.
func getItemsHandler(pool *pgxpool.Pool) fiber.Handler {
    return func(c *fiber.Ctx) error {
        limit, offset, err := parsePaginationParams(c)
        if err != nil {
            return c.Status(http.StatusBadRequest).JSON(fiber.Map{
                "error": err.Error(),
            })
        }

        var items []Item
        // Use parameterized queries to avoid injection and ensure CockroachDB receives safe values.
        query := `SELECT id, name, created_at FROM items ORDER BY created_at DESC LIMIT $1 OFFSET $2`
        rows, err := pool.Query(c.Context(), query, limit, offset)
        if err != nil {
            return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
                "error": "failed to execute query",
            })
        }
        defer rows.Close()

        for rows.Next() {
            var it Item
            if err := rows.Scan(&it.ID, &it.Name, &it.CreatedAt); err != nil {
                return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
                    "error": "failed to scan row",
                })
            }
            items = append(items, it)
        }

        return c.JSON(fiber.Map{
            "items": items,
        })
    }
}

type Item struct {
    ID        int64  `json:"id"`
    Name      string `json:"name"`
    CreatedAt string `json:"created_at"`
}

In this example, parsePaginationParams ensures that limit and offset are within safe ranges and cannot overflow int64. The query uses parameterized placeholders ($1, $2), so CockroachDB receives already-sanitized integers. This pattern avoids both SQL injection and unexpected wrap-around behavior in arithmetic.

For computations that involve multiplication or accumulation (such as calculating total size or batch allocations), perform explicit overflow checks before using the result in SQL or in memory operations. For example, if you must compute a total size as pageSize * pageNumber, validate that the result does not exceed a reasonable maximum and that each operand is within expected bounds before the multiplication.

middleBrick’s CLI tool can be used in development workflows to verify that endpoints reject malformed or extreme numeric inputs. By running middlebrick scan <url> against your Fiber service, you can observe how the scanner classifies input validation issues and data exposure risks around pagination and query construction.

If you integrate continuous monitoring, the Pro plan’s GitHub Action can fail builds when a scan detects findings related to input validation or data exposure, helping prevent regressions that could reintroduce overflow-sensitive logic. The Dashboard allows you to track these findings over time as you refine validation and query construction patterns.