Artifact [459bcd63e3]

Artifact 459bcd63e30312bbe9b01006cac33232c21e64a5976e73a401efba19c07b4202:

• File internal/repo/tablesync_identifier_test.go — part of check-in [3a6126c3e9] at 2026-10-11 01:34:31 on branch trunk — fix: harden sync and repository defaults (security) (#282)

  * fix(xfer): reject non-decimal card sizes and bound payload memory

  A payload card's size was parsed with strconv.Atoi, so a peer sending `file HASH -1` reached readPayload's negative-size assertion and panicked the client or server decoding the message, and a signed size such as `+5` was accepted. Sizes now go through parseSize, which follows the sync draft's `decimal = 1*DIGIT` grammar and fossil's 32-bit limit and returns a decoding error for anything else. uvfile FLAGS use the same parser, so negative FLAGS are rejected as the draft requires. The assertion stays, now unreachable from peer input.

  readPayload no longer allocates the declared size up front: its buffer grows with the bytes read, so a large size over a short message fails after allocating about what was sent.

  A cfile payload may inflate only to its USIZE (a margin above it for a delta) and not past its 4-byte size prefix, and all cfile payloads in one message share a MaxCFileInflateBytes (1 GiB) budget, so a few megabytes of zlib cannot inflate to tens of gigabytes.

  FuzzDecode exercises the decoder over both framings.

  * fix(sync): refuse malformed xrow payloads and cap HTTP reply bodies

  An xrow payload or xdelete PKData from a peer was decoded into a map and used as is. JSON null gave a nil map that reached coerceJSONNumbers' assertion, and a primary-key value of the wrong type or a nested value reached normalizeValue's, panicking the client or server. Both directions now decode through decodeRowJSON: one JSON object, nothing after it, and repo.ValidateRow's rules, which require scalar values and primary-key values that PKHash can normalize. A client refuses an xrow for a table it has not registered. Column types match case-insensitively, as table creation accepts them.

  Both HTTP transports read replies through xfer.ReadBody, which stops at MaxBodyBytes (MaxDecompressedBytes plus framing headroom) and returns ErrBodyTooLarge, untagged for retry, instead of reading an endless body into memory.

  FuzzTableSyncPayload drives the server handler and client over arbitrary payloads.

  * fix(sync): check synced-table rows and identifiers before building SQL

  repo.UpsertXRow wrote a row's map keys into its INSERT as column names, and the rows of an xrow payload or xdelete PKData come from the peer, so a key such as "val, mtime) VALUES(...) --" chose the statement's columns and values, and a key could select from other tables into a synced one. This held on the server for pushed rows and tombstones, and on the client for a server's rows.

  A peer's row must now use exactly the table's declared columns: repo.ValidateRow refuses any other key, which also keeps a peer from setting _owner. UpsertXRow no longer trusts its caller: it reads the table's registered schema and refuses any key it does not declare, apart from _owner on an ownership-mode table. ListXRows, LookupXRowOwner and DeleteXRowByPKHash validate the table name and the column names they interpolate, so no synced-table identifier reaches SQL text unchecked.

  * fix(sync): answer reqconfig only with fossil's transferable config

  The sync server answered reqconfig NAME with any row of the config table, for any requester, including one with no capabilities, so project-code, server-code and every local setting could be read by anyone who could reach the sync endpoint.

  handleReqConfig now follows fossil's page_xfer and configure.c. It answers only a /GROUP name, only for a requester with Read, matches the group by prefix in fossil's table order, and sends only the names fossil transfers in that group, in fossil's encoding. The user and subscriber tables also need Admin, which counts only for a verified login, and the concealed table needs RdAddr. A refused request gets no cards and no error.

  The groups, their names and their capability rules live in one place, config_groups.go. A differential test answers the same requests with fossil's own server and with HandleSync on the same repository and requires identical config cards.

  * test(sync): keep fossil http from leaving a backoffice process

  * fix(sync): check the login nonce against the request body

  The server verified a login card's signature over its nonce but never checked that the nonce was the SHA-1 of the request body after the login line, as fossil's check_tail_hash does (draft-fossil-sync-protocol-00 §6.2). A login card captured from one request therefore authenticated any other request body.

  The decoder now records, for each login card, the SHA-1 of the decompressed bytes after the card's line, and VerifyLogin refuses a card whose nonce does not match it. A login card that was never decoded has no tail and is refused.

  Login handling otherwise follows fossil's page_xfer and check_login: - a refused login ends the exchange with "error login failed" instead of continuing as nobody; - a second login card is refused with "multiple login cards"; - a successful login adds the user's capabilities to nobody's instead of replacing them; - nobody and anonymous log in without a password, and the reserved developer and reader logins and accounts with an empty password cannot be logged into.

  Fixes GHSA-2g5p-q5f3-477p.

  * fix(repo): seed nobody with fossil's default capabilities

  A new repository seeded the nobody user with "cghijknorswy", so every request without a login card could push check-ins and unversioned files, write wiki pages and tickets, and held Setup. Seed the four built-in users `fossil new` creates, with fossil's capabilities: nobody "gjorz", anonymous "hz", developer "ei" and reader "kptw".

  Setup and Admin now include check-in, read and clone, as they do in fossil, so the creating user can sync once given a password. A login to an account with no stored password is refused, as fossil's check_login refuses it; the creator starts with none, and the signature would otherwise be the SHA-1 of the nonce alone.

  Tests that push without credentials grant nobody push explicitly. Existing repositories keep their stored capabilities.

  * test(auth): reserved-login test updates the seeded developer and reader rows

  New repositories now seed developer and reader as fossil does, so the test gives the existing rows a password instead of inserting them.

  * docs(changelog): group the sync hardening fixes under Security

  * test(sync): reqconfig tests sign their logins over the request body

  The login nonce now has to cover the request body, so the reqconfig tests build their admin requests with signedRequest instead of a bare login card. (user: [email protected], size: 2877) [annotate] [blame] [check-ins using]

package repo

import "testing"

var identKV = TableDef{
	Columns:  []ColumnDef{{Name: "id", Type: "text", PK: true}, {Name: "val", Type: "text"}},
	Conflict: "mtime-wins",
}

func setupIdentRepo(t *testing.T) *Repo {
	t.Helper()
	r := setupTSRepo(t)
	if err := EnsureSyncSchema(r.DB()); err != nil {
		t.Fatalf("EnsureSyncSchema: %v", err)
	}
	if err := RegisterSyncedTable(r.DB(), "kv", identKV, 100); err != nil {
		t.Fatalf("RegisterSyncedTable: %v", err)
	}
	return r
}

func countKV(t *testing.T, r *Repo) int {
	t.Helper()
	var n int
	if err := r.DB().QueryRow("SELECT count(*) FROM x_kv").Scan(&n); err != nil {
		t.Fatalf("count x_kv: %v", err)
	}
	return n
}

// TestUpsertXRowRefusesUndeclaredColumns checks that a row key is used as a
// column name only when the table's registered schema declares it. Method:
// upsert rows whose extra key is a statement fragment. UpsertXRow wrote keys
// into its INSERT unchecked, so the first key below replaced the statement's
// column list and VALUES with the caller's own and stored the row 'inj'.
func TestUpsertXRowRefusesUndeclaredColumns(t *testing.T) {
	keys := []string{
		"val, mtime) VALUES('inj','x',7) --",
		"nosuch",
		"_owner", // only ownership-mode tables have it
	}
	for _, key := range keys {
		t.Run(key, func(t *testing.T) {
			r := setupIdentRepo(t)
			err := UpsertXRow(r.DB(), "kv", map[string]any{"id": "row1", key: "x"}, 1)
			if err == nil {
				t.Fatalf("UpsertXRow accepted column %q", key)
			}
			if n := countKV(t, r); n != 0 {
				t.Fatalf("x_kv holds %d rows after a refused upsert", n)
			}
		})
	}
}

// TestTableSyncSQLRefusesBadTableNames checks every function that writes a
// synced table's name into SQL text. Method: pass a name that is a statement
// fragment; each must return an error without running it.
func TestTableSyncSQLRefusesBadTableNames(t *testing.T) {
	r := setupIdentRepo(t)
	const bad = "kv WHERE 0; DELETE FROM blob; --"
	owned := identKV
	owned.Conflict = "owner-write"
	if err := UpsertXRow(r.DB(), bad, map[string]any{"id": "a"}, 1); err == nil {
		t.Error("UpsertXRow accepted a bad table name")
	}
	if err := UpsertXRow(r.DB(), "unregistered", map[string]any{"id": "a"}, 1); err == nil {
		t.Error("UpsertXRow accepted an unregistered table")
	}
	if _, _, err := ListXRows(r.DB(), bad, identKV); err == nil {
		t.Error("ListXRows accepted a bad table name")
	}
	if _, err := LookupXRowOwner(r.DB(), bad, owned, "abc"); err == nil {
		t.Error("LookupXRowOwner accepted a bad table name")
	}
	if _, err := DeleteXRowByPKHash(r.DB(), bad, identKV, "abc", 1); err == nil {
		t.Error("DeleteXRowByPKHash accepted a bad table name")
	}
	badCol := TableDef{Columns: []ColumnDef{{Name: "id = 1; --", Type: "text", PK: true}}}
	if _, err := DeleteXRowByPKHash(r.DB(), "kv", badCol, "abc", 1); err == nil {
		t.Error("DeleteXRowByPKHash accepted a bad column name")
	}
}