Artifact [13b504ed47]

Artifact 13b504ed476a81c01f61ed384fdcf010ccd2e9f439dd115ab6c1a1ceeb0432ba:

• File internal/xfer/example_test.go — part of check-in [a745f4f2ac] at 2026-07-28 00:44:04 on branch trunk — fix: make authenticated sync interoperate with canonical fossil (#207)

  * fix: make authenticated sync interoperate with canonical fossil (#203)

  Every credentialed sync against a real fossil server was answered "login failed", whether or not the password was right. Push always needs a login, so push was unusable against any real server, as was pull from anything that did not grant anonymous read.

  The login algorithm was never the problem. Two wire-level defects were, and each on its own produces that identical, password-independent rejection.

  The push and pull cards carried their two codes in the wrong order. The canonical form is `push SERVERCODE PROJECTCODE` — canonical's own client writes `blob_appendf(&send, "push %s %s\n", zSCode, zPCode)` and both ends read the project code out of the second argument (src/xfer.c). We emitted and parsed project code first. A clone therefore adopted the server's server-code as its project code, and since a login signature is salted with the project code, every signature was derived from the wrong value. The same inversion put the server code where a server validates the project code, so an authenticated push was refused with "wrong project" even once the login worked.

  The nonce covered a random comment that was never transmitted. The nonce is the hash of every byte following the login card, and the server re-hashes those bytes to check it (src/xfer.c check_tail_hash) — so the comment supplying the randomness has to be on the wire, not merely in the hash. We appended it to the hashed payload only, producing a nonce the server could not reproduce; it rejected the login before comparing the password at all, which is why a wrong password looked exactly like a right one. Comment lines now have a card type, so they can be sent as well as hashed.

  Two smaller faults on the same path: a clone treated the server's round-0 "not authorized to clone" as fatal, ending the session before credentials were ever offered, where canonical tolerates that error on the first cycle precisely so the client can retry with the login card it can only build once it knows the project code; and the sync path signed with SyncOpts.ProjectCode rather than the code it had already resolved from the repository, so a caller that let the repo supply its project code — as the push and pull cards allow — panicked instead of authenticating.

  The password derivation itself, sha1("<project-code>/<login>/<password>"), was correct and is unchanged. It is now pinned two ways: against the hash the fossil binary actually stores in user.pw, and against a login card captured from fossil 2.28 on the wire. Canonical's rule that an already hashed 40-hex password is used as-is is now honoured too.

  Regression coverage stands up a canonical fossil server with anonymous capabilities removed, so a login card is the only way in, and asserts that a credentialed clone transfers content, a wrong password is refused, and a local commit pushed under authentication lands in the server's blob table and on its timeline. Nothing in the suite authenticated against real fossil before; clone was only ever exercised against servers granting anonymous read, where the login card is never sent, which is how this shipped.

  Four xfer codec expectations that pinned the inverted argument order are corrected to the canonical bytes.

  * fix(sync): correct the nonce doc to match what the server recomputes

  The comment described the nonce as covering the encoded non-login cards and the signature as using the stored password hash. Both readings are wrong in ways that matter to anyone changing this code: the nonce is defined over the bytes that actually follow the login card on the wire, because the server recomputes it from what it received (src/xfer.c check_tail_hash), and the signature is salted with the project code rather than derived from user.pw directly. Hashing bytes the message does not carry produces a nonce the peer cannot reproduce, which is exactly the password-independent rejection this fix was chasing. (user: [email protected], size: 811) [annotate] [blame] [check-ins using]

package xfer_test

import (
	"fmt"

	"github.com/danmestas/go-libfossil/internal/xfer"
)

func ExampleMessage_Encode() {
	msg := &xfer.Message{
		Cards: []xfer.Card{
			&xfer.PushCard{ProjectCode: "abc123", ServerCode: "def456"},
			&xfer.PullCard{ProjectCode: "abc123", ServerCode: "def456"},
			&xfer.IGotCard{UUID: "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"},
		},
	}

	wire, err := msg.Encode()
	if err != nil {
		fmt.Println("error:", err)
		return
	}

	// Wire format is zlib-compressed xfer cards.
	fmt.Printf("compressed: %v\n", len(wire) > 0)

	// Decode round-trips back to a Message.
	decoded, err := xfer.Decode(wire, xfer.ContentTypeCompressed)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Printf("cards: %d\n", len(decoded.Cards))
	// Output:
	// compressed: true
	// cards: 3
}