Integer Overflow in Chi with Cockroachdb

Integer overflow in a Chi handler that persists values to CockroachDB can occur when arithmetic on 64-bit integers exceeds the maximum value representable in the programming language, producing a wrapped value that is then stored or used in queries. In Go, if you compute an offset or an accumulated size using integers and pass the result to SQL without validation, the wrapped integer may generate unexpected LIMIT/OFFSET values or incorrect arithmetic in CockroachDB SQL expressions, leading to data corruption or unsafe memory access patterns.

Chi routes are often used to bind numeric path parameters (e.g., /users/{id}) and query parameters (e.g., ?page=2&size=50) that are forwarded to CockroachDB. If these values are parsed into integers and then used in calculations such as (page * size) to compute offsets, an unchecked multiplication can overflow. Cockroachdb correctly stores the final integer value, but if the wrapped integer is used to construct SQL, it may bypass intended bounds, causing large offsets or negative values that violate application assumptions or expose more rows than expected.

Another scenario involves computed timestamps or counters stored in CockroachDB. For example, incrementing a version integer on each update without checking for max int64 can wrap to a very small number, which may be interpreted by the application as a newer version than reality, causing logical corruption. Since CockroachDB does not inherently protect against application-level integer overflow, the database will faithfully persist the incorrect value produced by the Chi handler, making the issue hard to detect without runtime monitoring or input validation.

To detect this with middleBrick, which scans unauthenticated attack surfaces and tests input validation among 12 security checks, you can submit your API endpoint to observe whether large numeric inputs trigger unexpected behavior in SQL execution plans or response data. middleBrick does not fix the overflow but highlights findings with severity and remediation guidance, helping you identify unsafe arithmetic before it leads to data inconsistency or security issues.

Remediation focuses on validating and sanitizing inputs before they are used in arithmetic or SQL, and using safe types or checks in Go to avoid overflow. Prefer using 64-bit unsigned checks or big integers for critical calculations, and enforce server-side constraints in CockroachDB to reject invalid values.

Example 1: Safe offset calculation for pagination

Instead of multiplying page and size directly, validate ranges and use checked arithmetic:

import (
    "math"
    "net/http"

    "github.com/go-chi/chi/v5"
)

func safeOffset(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        page := chi.URLParam(r, "page")
        size := chi.URLParam(r, "size")
        // Convert and validate
        p, err := strconv.ParseInt(page, 10, 64)
        if err != nil || p < 1 { p = 1 }
        s, err := strconv.ParseInt(size, 10, 64)
        if err != nil || s < 1 || s > 100 { s = 20 }
        if p > math.MaxInt64/s { // would overflow
            http.Error(w, "invalid pagination", http.StatusBadRequest)
            return
        }
        offset := p * s
        // Use placeholders to avoid SQL injection
        rows, err := db.Query(context.Background(), `SELECT id, name FROM users LIMIT $1 OFFSET $2`, s, offset)
        // handle rows...
    })
}

r := chi.NewRouter()
r.Get("/users", safeOffset)

Example 2: Version counter with CockroachDB constraint

Use a table constraint to ensure versions remain within safe bounds, and update in a transaction:

-- CockroachDB schema
CREATE TABLE documents (
    id UUID PRIMARY KEY,
    content STRING,
    version INT NOT NULL CHECK (version BETWEEN 0 AND 9223372036854775807)
);

import (
    "context"
    "database/sql"
)

func incrementVersion(ctx context.Context, docID string, db *sql.DB) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()
    var current int
    err = tx.QueryRowContext(ctx, "SELECT version FROM documents WHERE id = $1 FOR UPDATE", docID).Scan(&current)
    if err != nil {
        return err
    }
    if current == math.MaxInt64 {
        return errors.New("version overflow")
    }
    _, err = tx.ExecContext(ctx, "UPDATE documents SET version = $1 WHERE id = $2", current+1, docID)
    if err != nil {
        return err
    }
    return tx.Commit()
}

These examples ensure arithmetic stays within safe ranges and CockroachDB enforces domain constraints. By combining input validation in Chi with schema-level checks, you reduce the risk of overflow corrupting persisted data.