From 8ca7ca096fe2cfe92850532254219d95331757eb Mon Sep 17 00:00:00 2001 From: Daniel Golle Date: Mon, 3 Aug 2026 19:35:46 +0100 Subject: [PATCH 1/2] Fix compare-and-swap check for mutable put CheckIncoming compared the stored item's Cas field against the incoming Cas and returned early whenever the stored Cas was 0. Items are stored without a meaningful Cas, so the compare-and-swap never fired and a stale update could overwrite the value. Compare the incoming put's cas against the stored item's seq, as BEP 44 specifies, treating an absent cas (0) as no compare-and-swap requested. --- bep44/item.go | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/bep44/item.go b/bep44/item.go index f87314102..ad076fb66 100644 --- a/bep44/item.go +++ b/bep44/item.go @@ -164,12 +164,10 @@ func CheckIncoming(stored, incoming *Item) error { return ErrSequenceNumberLessThanCurrent } - // Cas should be ignored if not present - if stored.Cas == 0 { - return nil - } - - if stored.Cas != incoming.Cas { + // cas (compare-and-swap) is the sequence number the writer expects to be + // replacing; per BEP 44 it must equal the *stored* item's current seq, + // otherwise the put is rejected. An absent cas (0) means "no cas". + if incoming.Cas != 0 && incoming.Cas != stored.Seq { return ErrCasHashMismatched } From ae12d7b6dfab5fdf7b9e6cda99dac9ef89d92713 Mon Sep 17 00:00:00 2001 From: Daniel Golle Date: Mon, 31 Aug 2026 13:49:09 +0100 Subject: [PATCH 2/2] Test compare-and-swap handling in CheckIncoming Cover the cas acceptance and rejection matrix directly: an absent cas is ignored, a cas equal to the stored seq is accepted, and a cas that differs from the stored seq is rejected with ErrCasHashMismatched. The stored item's own Cas field is not consulted, and the sequence number check still runs ahead of the cas check. TestWrapperCas walks the same path through Wrapper.Put with signed mutable items, so a writer that still believes an older seq is current cannot overwrite the newer value. --- bep44/item_test.go | 73 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 bep44/item_test.go diff --git a/bep44/item_test.go b/bep44/item_test.go new file mode 100644 index 000000000..197260d67 --- /dev/null +++ b/bep44/item_test.go @@ -0,0 +1,73 @@ +package bep44 + +import ( + "crypto/ed25519" + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestCheckIncomingCas(t *testing.T) { + for _, c := range []struct { + name string + storedSeq int64 + storedCas int64 + incomingSeq int64 + incomingCas int64 + err error + }{ + {name: "absent cas", storedSeq: 1, incomingSeq: 2}, + {name: "cas equal to stored seq", storedSeq: 1, incomingSeq: 2, incomingCas: 1}, + {name: "stored cas is not consulted", storedSeq: 1, storedCas: 7, incomingSeq: 2, incomingCas: 1}, + { + name: "cas below stored seq", storedSeq: 2, incomingSeq: 3, incomingCas: 1, + err: ErrCasHashMismatched, + }, + { + name: "cas above stored seq", storedSeq: 1, incomingSeq: 2, incomingCas: 2, + err: ErrCasHashMismatched, + }, + { + name: "seq not greater than stored", storedSeq: 2, incomingSeq: 2, incomingCas: 2, + err: ErrSequenceNumberLessThanCurrent, + }, + } { + t.Run(c.name, func(t *testing.T) { + require := require.New(t) + stored := &Item{V: "stored", Seq: c.storedSeq, Cas: c.storedCas} + incoming := &Item{V: "incoming", Seq: c.incomingSeq, Cas: c.incomingCas} + err := CheckIncoming(stored, incoming) + if c.err == nil { + require.NoError(err) + } else { + require.ErrorIs(err, c.err) + } + }) + } +} + +func TestWrapperCas(t *testing.T) { + require := require.New(t) + w := NewWrapper(NewMemory(), 10*time.Hour) + + _, k, err := ed25519.GenerateKey(nil) + require.NoError(err) + + first, err := NewItem("first", nil, 1, 0, k) + require.NoError(err) + require.NoError(w.Put(first)) + + second, err := NewItem("second", nil, 2, 1, k) + require.NoError(err) + require.NoError(w.Put(second)) + + // A writer that still believes seq 1 is current must not overwrite seq 2. + stale, err := NewItem("stale", nil, 3, 1, k) + require.NoError(err) + require.ErrorIs(w.Put(stale), ErrCasHashMismatched) + + kept, err := w.Get(second.Target()) + require.NoError(err) + require.Equal("second", kept.V) +}