fix(syncguard): spot-check proof by bnum offset, not tfile tail

Two bugs uncovered during end-to-end WSL smoke testing on mainnet:

1. sg_proof_match_tfile_tail() required the proof segment to sit
   byte-exactly at the TAIL of the downloaded tfile. If the peer's
   chain advanced between scan_quorum() (proof fetch) and resync()
   (full tfile download) — even by a single block — the proof would
   no longer be at the tail and the check would fire false positives.
   Since tfile trailers are stored in bnum-continuous order starting
   from genesis (trailer at byte offset N*sizeof(BTRAILER) has
   bnum==N), we can instead seek directly to proof[0].bnum's offset
   and compare the proof's historical trailers in place. The tfile
   may have advanced past the proof's tip, but the proof's own range
   is historical and cannot change without a reorg. Renamed to
   sg_proof_match_tfile() to reflect the new semantics.

2. resync() called sg_session_reset() at entry, which also cleared
   the proof cache that scan_quorum() had just populated. The proofs
   must persist across the scan→resync boundary. Session reset is
   no longer automatic on resync(); the session caches now persist
   for the lifetime of the process (zero-initialized at startup via
   static storage, overwritten naturally on re-scan). sg_session_reset()
   remains available as an exported helper.

Also downgraded diagnostic logs in sg_proof_match_tfile() from plog()
to pdebug() so they only appear at debug log level.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: adequatelimited

src/sync.c

@@ -216,10 +216,13 @@ int resync(word32 quorum[], word32 *qidx, void *highhash, void *highweight,
       return VERROR;
    }
 
-   /* Phase 3: reset session-local caches at the start of each resync
-    * attempt. Bad-tfile and bad-chain caches are only meaningful within
-    * the scope of a single sync attempt. */
-   sg_session_reset();
+   /* NOTE: session-local caches (bad-chain, bad-tfile, proofs) are not
+    * reset here. The proof cache was populated by scan_quorum() and must
+    * persist through the gettfile loop for the spot-check below to work.
+    * bad-chain and bad-tfile caches must persist across resync retries
+    * within the same process so we don't fall into repeated failures
+    * on the same malicious peers. All caches are zero-initialized at
+    * process start via static storage duration. */
 
    show("gettfile");  /* get tfile */
    pdebug("fetching tfile.dat from %s", ntoa(&quorum[0], ipaddr));
@@ -273,12 +276,15 @@ int resync(word32 quorum[], word32 *qidx, void *highhash, void *highweight,
          continue;
       }
 
-      /* Phase 3 tail spot-check: the peer's validated proof segment
-       * from scan_quorum() must appear byte-exactly at the tail of
-       * the tfile they just served. Mismatch = they served a
-       * different chain than they advertised. */
-      if (sg_proof_match_tfile_tail(*quorum, "tfile.dat", NTFTX) != VEOK) {
-         pdebug("gettfile: %s tfile tail does NOT match its advertised "
+      /* Phase 3 spot-check: the peer's validated proof segment from
+       * scan_quorum() must appear byte-exactly at the corresponding
+       * bnum offset in the tfile they just served. The tfile may have
+       * advanced past the proof's tip if the peer received new blocks
+       * between scan_quorum() and resync(); we only require that the
+       * historical trailers at the proof's bnum range match exactly.
+       * Mismatch = they served a different chain than they advertised. */
+      if (sg_proof_match_tfile(*quorum, "tfile.dat") != VEOK) {
+         pdebug("gettfile: %s tfile does NOT match its advertised "
             "proof -- marking tfile bad", ntoa(quorum, ipaddr));
          sg_bad_tfile_add(tfile_hash);
          remove("tfile.dat");

src/syncguard.c

@@ -17,6 +17,7 @@
 
 /* external support */
 #include "extmath.h"  /* cmp64 */
+#include "extlib.h"   /* get32 */
 #include "sha256.h"
 #include "extio.h"    /* plog/perr */
 
@@ -186,39 +187,63 @@ void sg_proof_clear_all(void)
    memset(Proofs, 0, sizeof(Proofs));
 }
 
-/* Compare the tail of tfile at fname byte-exactly against the cached
- * proof segment for ip. Returns VEOK on match, VERROR on any mismatch
- * or I/O failure.
- * Caller should sg_bad_tfile_add() on mismatch. */
-int sg_proof_match_tfile_tail(word32 ip, const char *tfname, word32 count)
+/* Compare the cached proof segment for ip against the corresponding
+ * range of trailers in the tfile at fname. The proof's first trailer
+ * should appear at offset proof[0].bnum * sizeof(BTRAILER) in the
+ * tfile (trailers are stored in bnum order starting from the genesis
+ * block). The tfile may have advanced past the proof's tip if the
+ * peer mined or received new blocks between scan_quorum() and
+ * resync(); we only care that the proof's historical trailers match
+ * the corresponding positions in the tfile.
+ *
+ * Returns VEOK on byte-exact match, VERROR on any mismatch, I/O
+ * failure, or if the tfile does not contain the proof's range. */
+int sg_proof_match_tfile(word32 ip, const char *tfname)
 {
    sg_proof_t *p;
    FILE *fp;
    long long len, off;
    BTRAILER bt;
    word32 i;
+   word64 first_bnum;
 
    p = sg_proof_find(ip);
-   if (p == NULL) return VERROR;
-   if (count == 0 || count > p->count) count = p->count;
+   if (p == NULL) {
+      pdebug("sg_proof_match_tfile: no cached proof for peer");
+      return VERROR;
+   }
+   if (p->count == 0) return VERROR;
+
+   /* compute byte offset for proof[0].bnum */
+   memcpy(&first_bnum, p->proof[0].bnum, 8);
 
    fp = fopen(tfname, "rb");
    if (fp == NULL) return VERROR;
+
+   /* check tfile length covers the proof range */
    if (fseek64(fp, 0LL, SEEK_END) != 0) { fclose(fp); return VERROR; }
    len = ftell64(fp);
-   if (len < (long long)(count * sizeof(BTRAILER))) {
+   off = (long long)(first_bnum * sizeof(BTRAILER));
+   if (len < off + (long long)(p->count * sizeof(BTRAILER))) {
+      pdebug("sg_proof_match_tfile: tfile too short (len=%lld, need=%lld)",
+         len, off + (long long)(p->count * sizeof(BTRAILER)));
       fclose(fp);
       return VERROR;
    }
-   off = len - (long long)(count * sizeof(BTRAILER));
    if (fseek64(fp, off, SEEK_SET) != 0) { fclose(fp); return VERROR; }
 
-   for (i = 0; i < count; i++) {
+   for (i = 0; i < p->count; i++) {
       if (fread(&bt, sizeof(BTRAILER), 1, fp) != 1) {
+         pdebug("sg_proof_match_tfile: fread failed at proof[%u]", i);
          fclose(fp);
          return VERROR;
       }
       if (memcmp(&bt, &p->proof[i], sizeof(BTRAILER)) != 0) {
+         word32 tfile_bnum = (word32) get32(bt.bnum);
+         word32 proof_bnum = (word32) get32(p->proof[i].bnum);
+         pdebug("sg_proof_match_tfile: mismatch at proof[%u] "
+            "(tfile bnum=0x%x, proof bnum=0x%x)",
+            i, tfile_bnum, proof_bnum);
          fclose(fp);
          return VERROR;
       }

src/syncguard.h

@@ -12,8 +12,15 @@
  *   - Session-local cache of known-bad (weight, hash) chain pairs used
  *     as an exclusion list when re-scanning after a quorum fails
  *
- * All caches are in-memory and cleared at the start of each resync()
- * attempt. No on-disk persistence.
+ * All caches are in-memory and live for the lifetime of the process.
+ * They are zero-initialized at startup via static storage duration.
+ * Bad-chain and bad-tfile caches intentionally persist across resync()
+ * retries so the node does not repeatedly fall into the same bad
+ * actors. Proofs are populated by scan_quorum() and consumed by
+ * resync(); stale proof entries are harmless (only used in lookups
+ * keyed by current quorum-member IP) and are naturally overwritten on
+ * subsequent scans of the same peer. sg_session_reset() is provided
+ * for explicit clearing if ever required.
  */
 
 /* include guard */
@@ -52,7 +59,7 @@ int  sg_hash_file(const char *fname, word8 out[HASHLEN]);
 /* Per-peer proof segment cache (session-local) */
 void sg_proof_store(word32 ip, const BTRAILER *proof, word32 count);
 int  sg_proof_get(word32 ip, BTRAILER *out, word32 count);
-int  sg_proof_match_tfile_tail(word32 ip, const char *tfname, word32 count);
+int  sg_proof_match_tfile(word32 ip, const char *tfname);
 void sg_proof_clear_all(void);
 
 /* Proof validation: structural chain climb + tip hash match against advertised.