Distributed Denial Of Service in Echo Go with Cockroachdb

A DDoS scenario involving Echo Go and CockroachDB typically arises not from a flaw in CockroachDB itself, but from how an Echo Go service manages database connections and query execution under load. When many concurrent requests hit an Echo endpoint that opens a new CockroachDB session or transaction per request without effective controls, the database can become overwhelmed by connection count and query volume. This creates contention, increased latency, and eventual resource exhaustion at the application or database layer.

In a black-box scan, middleBrick tests for rate limiting and input validation at the API surface. If an endpoint accepts user-supplied parameters that directly shape database queries—such as a query parameter used to filter a large table without pagination—unbounded or expensive queries can consume CPU and I/O on CockroachDB nodes. This is especially risky when the endpoint does not enforce timeouts on the database context, allowing a single slow query to hold connections and goroutines open.

SSRF findings can also intersect with DDoS risk if an attacker can cause the service to open unexpected network connections to CockroachDB nodes or to external resolvers, creating additional load. Since middleBrick checks for SSRF and unauthenticated endpoints, it can highlight endpoints that may be leveraged in a DDoS chain against the database. The combination of high request rates, missing context timeouts, and lack of query cost controls can degrade availability across the Echo Go service and its CockroachDB backend.

Apply structured concurrency and context timeouts to ensure that each request does not hold database resources indefinitely. Use a shared, bounded connection pool and enforce query limits through context cancellation and sensible timeouts.

// main.go
package main

import (
	"context"
	"net/http"
	"time"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"github.com/lib/pq"
)

func main() {
	e := echo.New()
	e.Use(middleware.TimeoutWithConfig(middleware.TimeoutConfig{
		Timeout: 5 * time.Second,
	}))

	httpClient := &http.Client{
		Timeout: 10 * time.Second,
	}
	// Example: use a connection pool provided by your DB driver.
	// Configure MaxOpenConns, MaxIdleConns, and ConnMaxLifetime appropriately.
	db, err := sql.Open("postgres", "postgresql://user:password@host:26257/dbname?sslmode=require")
	if err != nil {
		http.Error(nil, "failed to connect", http.StatusInternalServerError)
		return
	}
	defer db.Close()

	e.GET("/users/:id", func(c echo.Context) error {
		ctx, cancel := context.WithTimeout(c.Request().Context(), 2*time.Second)
		defer cancel()

		var user User
		row := db.QueryRowContext(ctx, "SELECT id, name, email FROM users WHERE id = $1 LIMIT 1", c.Param("id"))
		if err := row.Scan(&user.ID, &user.Name, &user.Email); err != nil {
			if err == context.DeadlineExceeded {
				return c.JSON(http.StatusGatewayTimeout, map[string]string{"error": "database timeout"})
			}
			return c.JSON(http.StatusInternalServerError, map[string]string{"error": "unable to fetch user"})
		}
		return c.JSON(http.StatusOK, user)
	})

	// Admin endpoint with pagination and cost controls
	e.GET("/users", func(c echo.Context) error {
		page, err := strconv.Atoi(c.QueryParam("page"))
		if err != nil || page < 1 {
			page = 1
		}
		size := 50
		if size > 100 {
			size = 100
		}
		ctx, cancel := context.WithTimeout(c.Request().Context(), 3*time.Second)
		defer cancel()

		rows, err := db.QueryContext(ctx,
			"SELECT id, name, email FROM users ORDER BY id LIMIT $1 OFFSET $2",
			size, (page-1)*size)
		if err != nil {
			return c.JSON(http.StatusInternalServerError, map[string]string{"error": "query failed"})
		}
		defer rows.Close()

		var users []User
		for rows.Next() {
			var u User
			if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
				return c.JSON(http.StatusInternalServerError, map[string]string{"error": "scan error"})
			}
			users = append(users, u)
		}
		if err := rows.Err(); err != nil {
			return c.JSON(http.StatusInternalServerError, map[string]string{"error": "rows error"})
		}
		return c.JSON(http.StatusOK, users)
	})

	// Start server with timeouts
	server := &http.Server{
		Addr:           ":8080",
		Handler:        e,
		ReadTimeout:    5 * time.Second,
		WriteTimeout:   10 * time.Second,
		IdleTimeout:    60 * time.Second,
	}
	http.ListenAndServe(":8080", server)
}

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

Use context.WithTimeout on every database call and ensure the Echo request context is propagated. Configure the SQL driver and CockroachDB connection pool to limit open connections and prevent resource exhaustion. Avoid unbounded queries; enforce pagination and cap result sizes. Validate and sanitize all inputs that influence WHERE clauses to prevent expensive or unintended scans. These steps reduce the likelihood that a high request volume or malicious input will degrade availability across the Echo Go service and its CockroachDB backend.