git/list[1] front-page[2] threads[3] people[4] search[5] about
 

[PATCH v2 11/12] reftable/table: fix NULL pointer access when seeking to bogus offsets

From
Patrick Steinhardt <ps@pks.im>
Date
Jun 29, 2026, 09:02 UTC
Message-ID
<20260629-pks-reftable-hardening-v2-11-b0228e7d908d@pks.im>
In-Reply-To
<20260629-pks-reftable-hardening-v2-0-b0228e7d908d@pks.im>

When seeking an iterator to an arbitrary offset we may return a positive value in case the offset points beyond the block. This makes sense when iterating through multiple blocks of the same section, as the positive value indicates to us that we're at the end of the table.

But when the offset originates from a section or index offset it is supposed to point at a valid block, so an out-of-bounds value means that the table is corrupt. Treating it as a normal end-of-iteration causes us to silently report an empty section instead of surfacing the corruption, and we are left with a partially-initialized block. This may later on cause a NULL pointer exception:

  ==1486841==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x55555598e02c bp 0x7fffffff4eb0 sp 0x7fffffff4e70 T0)
  ==1486841==The signal is caused by a READ memory access.
  ==1486841==Hint: address points to the zero page.
      #0 0x55555598e02c in reftable_block_type ./git/build/../reftable/block.c:392:9
      #1 0x55555598ee6e in block_iter_seek_key ./git/build/../reftable/block.c:536:35
      #2 0x5555559ae553 in table_iter_seek_linear ./git/build/../reftable/table.c:344:8
      #3 0x5555559adbff in table_iter_seek ./git/build/../reftable/table.c:450:9
      #4 0x5555559ada9c in table_iter_seek_void ./git/build/../reftable/table.c:460:9
      #5 0x555555992872 in reftable_iterator_seek_log_at ./git/build/../reftable/iter.c:281:9
      #6 0x555555992953 in reftable_iterator_seek_log ./git/build/../reftable/iter.c:287:9
      #7 0x55555583aa78 in test_reftable_table__seek_invalid_log_offset ./git/build/../t/unit-tests/u-reftable-table.c:257:20
      #8 0x5555557f684e in clar_run_test ./git/build/../t/unit-tests/clar/clar.c:335:3
      #9 0x5555557f2e69 in clar_run_suite ./git/build/../t/unit-tests/clar/clar.c:431:3
      #10 0x5555557f2882 in clar_test_run ./git/build/../t/unit-tests/clar/clar.c:636:4
      #11 0x5555557f375f in clar_test ./git/build/../t/unit-tests/clar/clar.c:687:11
      #12 0x5555557fa49d in cmd_main ./git/build/../t/unit-tests/unit-test.c:62:8
      #13 0x55555584cffa in main ./git/build/../common-main.c:9:11
      #14 0x7ffff7a2b284 in __libc_start_call_main (/nix/store/57iz36553175g3178pvxjij8z5rcsd4n-glibc-2.42-61/lib/libc.so.6+0x2b284) (BuildId: 8ae0b698f2d4e727f569f64bb166e08ae30bd077)
      #15 0x7ffff7a2b337 in __libc_start_main@GLIBC_2.2.5 (/nix/store/57iz36553175g3178pvxjij8z5rcsd4n-glibc-2.42-61/lib/libc.so.6+0x2b337) (BuildId: 8ae0b698f2d4e727f569f64bb166e08ae30bd077)
      #16 0x555555694c24 in _start (./git/build/t/unit-tests+0x140c24)
  ==1486841==Register values:
  rax = 0x0000000000000000  rbx = 0x00007fffffff4ec0  rcx = 0x0000000000000000  rdx = 0x00007cfff6e2bd58
  rdi = 0x00007cfff6e2bd58  rsi = 0x00007bfff5da1020  rbp = 0x00007fffffff4eb0  rsp = 0x00007fffffff4e70
   r8 = 0x0000000000000000   r9 = 0x0000000000000002  r10 = 0x0000000000000000  r11 = 0x0000000000000017
  r12 = 0x00007fffffff5908  r13 = 0x0000000000000001  r14 = 0x00007ffff7ffd000  r15 = 0x0000555556056e90
  AddressSanitizer can not provide additional info.
  SUMMARY: AddressSanitizer: SEGV ./git/build/../reftable/block.c:392:9 in reftable_block_type
  ==1486841==ABORTING

Fix this by returning a proper error in `table_iter_seek_to()` when the offset ranges beyond the block.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
 reftable/table.c                |  2 ++
 t/unit-tests/u-reftable-table.c | 63 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+)
diff --git a/reftable/table.c b/reftable/table.c
index 56362df0ed..f4bc86a29d 100644
--- a/reftable/table.c
+++ b/reftable/table.c
@@ -242,6 +242,8 @@ static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ)
 	int err;
 
 	err = table_init_block(ti->table, &ti->block, off, typ);
+	if (err > 0)
+		return REFTABLE_FORMAT_ERROR;
 	if (err != 0)
 		return err;
 
diff --git a/t/unit-tests/u-reftable-table.c b/t/unit-tests/u-reftable-table.c
index 14fae8b199..c7dca45e70 100644
--- a/t/unit-tests/u-reftable-table.c
+++ b/t/unit-tests/u-reftable-table.c
@@ -1,8 +1,11 @@
 #include "unit-test.h"
 #include "lib-reftable.h"
+#include "reftable/basics.h"
+#include "reftable/block.h"
 #include "reftable/blocksource.h"
 #include "reftable/constants.h"
 #include "reftable/iter.h"
+#include "reftable/reftable-error.h"
 #include "reftable/table.h"
 #include "strbuf.h"
 
@@ -199,3 +202,63 @@ void test_reftable_table__block_iterator(void)
 	reftable_buf_release(&buf);
 	reftable_free(records);
 }
+
+void test_reftable_table__seek_invalid_log_offset(void)
+{
+	struct reftable_ref_record refs[] = {
+		{
+			.refname = (char *) "refs/heads/main",
+			.value_type = REFTABLE_REF_VAL1,
+			.value.val1 = { 42 },
+		},
+	};
+	struct reftable_log_record logs[] = {
+		{
+			.refname = (char *) "refs/heads/main",
+			.update_index = 1,
+			.value_type = REFTABLE_LOG_UPDATE,
+			.value.update = {
+				.name = (char *) "user",
+				.email = (char *) "user@example.com",
+				.message = (char *) "message\n",
+			},
+		},
+	};
+	struct reftable_block_source source = { 0 };
+	struct reftable_log_record log = { 0 };
+	struct reftable_iterator it = { 0 };
+	struct reftable_table *table;
+	struct reftable_buf buf = REFTABLE_BUF_INIT;
+	size_t fsize = footer_size(1);
+	uint8_t *footer;
+
+	cl_reftable_write_to_buf(&buf, refs, ARRAY_SIZE(refs),
+				 logs, ARRAY_SIZE(logs), NULL);
+
+	/*
+	 * Corrupt the log section offset stored in the footer so that it points
+	 * past the end of the table. The footer is checksummed, so we also have
+	 * to recompute and rewrite the CRC.
+	 */
+	footer = (uint8_t *) buf.buf + buf.len - fsize;
+	reftable_put_be64(footer + header_size(1) + 24, UINT64_MAX);
+	reftable_put_be32(footer + fsize - 4, crc32(0, footer, fsize - 4));
+
+	block_source_from_buf(&source, &buf);
+	cl_must_pass(reftable_table_new(&table, &source, "name"));
+
+	/*
+	 * Seeking the log iterator must not crash even though the log section
+	 * offset is bogus. As the offset points past the end of the table we
+	 * know that the table is corrupt, so the seek must report a format
+	 * error instead of pretending that the section is empty.
+	 */
+	reftable_table_init_log_iterator(table, &it);
+	cl_assert_equal_i(reftable_iterator_seek_log(&it, ""),
+			  REFTABLE_FORMAT_ERROR);
+
+	reftable_log_record_release(&log);
+	reftable_iterator_destroy(&it);
+	reftable_table_decref(table);
+	reftable_buf_release(&buf);
+}
-- 
2.55.0.rc2.803.g1fd1e6609c.dirty
Previous: Patrick SteinhardtNext: Patrick Steinhardt
Message 33 of 48 in “reftable: harden against corrupted tables”
  1. 00/11 reftable: harden against corrupted tablesPatrick Steinhardt, Jun 24, 2026
  2. 01/11 meson: support building fuzzers with libFuzzerPatrick Steinhardt, Jun 24, 2026
  3. 02/11 oss-fuzz: add fuzzer for parsing reftablesPatrick Steinhardt, Jun 24, 2026
  4. 03/11 reftable/basics: fix OOB read on binary search of empty rangePatrick Steinhardt, Jun 24, 2026
  5. 04/11 reftable/record: don't abort when decoding invalid ref value typePatrick Steinhardt, Jun 24, 2026
  6. 05/11 reftable/block: fix OOB write with bogus inflated log sizePatrick Steinhardt, Jun 24, 2026
  7. Christian CouderJun 26, 2026
  8. Patrick SteinhardtJun 29, 2026
  9. 06/11 reftable/block: fix OOB read with bogus block sizePatrick Steinhardt, Jun 24, 2026
  10. 07/11 reftable/block: fix OOB read with bogus restart countPatrick Steinhardt, Jun 24, 2026
  11. 08/11 reftable/block: fix use of uninitialized memory when binsearch failsPatrick Steinhardt, Jun 24, 2026
  12. 09/11 reftable/block: fix OOB read with bogus restart offsetPatrick Steinhardt, Jun 24, 2026
  13. 10/11 reftable/table: fix NULL pointer access when seeking to bogus offsetsPatrick Steinhardt, Jun 24, 2026
  14. 11/11 reftable/table: fix OOB read on truncated tablePatrick Steinhardt, Jun 24, 2026
  15. 00/12 reftable: harden against corrupted tablesPatrick Steinhardt, Jun 29, 2026
  16. 01/12 meson: support building fuzzers with libFuzzerPatrick Steinhardt, Jun 29, 2026
  17. 02/12 oss-fuzz: add fuzzer for parsing reftablesPatrick Steinhardt, Jun 29, 2026
  18. 03/12 reftable/basics: fix OOB read on binary search of empty rangePatrick Steinhardt, Jun 29, 2026
  19. 04/12 reftable/record: don't abort when decoding invalid ref value typePatrick Steinhardt, Jun 29, 2026
  20. 05/12 t/unit-tests: introduce test helper to write reftable blocksPatrick Steinhardt, Jun 29, 2026
  21. Junio C HamanoJun 30, 2026
  22. Christian CouderJul 2, 2026
  23. Junio C HamanoJul 3, 2026
  24. 06/12 reftable/block: fix OOB write with bogus inflated log sizePatrick Steinhardt, Jun 29, 2026
  25. Toon ClaesJul 3, 2026
  26. Patrick SteinhardtJul 3, 2026
  27. 07/12 reftable/block: fix OOB read with bogus block sizePatrick Steinhardt, Jun 29, 2026
  28. Toon ClaesJul 3, 2026
  29. Patrick SteinhardtJul 3, 2026
  30. 08/12 reftable/block: fix OOB read with bogus restart countPatrick Steinhardt, Jun 29, 2026
  31. 09/12 reftable/block: fix use of uninitialized memory when binsearch failsPatrick Steinhardt, Jun 29, 2026
  32. 10/12 reftable/block: fix OOB read with bogus restart offsetPatrick Steinhardt, Jun 29, 2026
  33. 11/12 reftable/table: fix NULL pointer access when seeking to bogus offsetsPatrick Steinhardt, Jun 29, 2026
  34. 12/12 reftable/table: fix OOB read on truncated tablePatrick Steinhardt, Jun 29, 2026
  35. 00/12 reftable: harden against corrupted tablesPatrick Steinhardt, Jul 3, 2026
  36. 01/12 meson: support building fuzzers with libFuzzerPatrick Steinhardt, Jul 3, 2026
  37. 02/12 oss-fuzz: add fuzzer for parsing reftablesPatrick Steinhardt, Jul 3, 2026
  38. 03/12 reftable/basics: fix OOB read on binary search of empty rangePatrick Steinhardt, Jul 3, 2026
  39. 04/12 reftable/record: don't abort when decoding invalid ref value typePatrick Steinhardt, Jul 3, 2026
  40. 05/12 t/unit-tests: introduce test helper to write reftable blocksPatrick Steinhardt, Jul 3, 2026
  41. 06/12 reftable/block: fix OOB write with bogus inflated log sizePatrick Steinhardt, Jul 3, 2026
  42. 07/12 reftable/block: fix OOB read with bogus block sizePatrick Steinhardt, Jul 3, 2026
  43. 08/12 reftable/block: fix OOB read with bogus restart countPatrick Steinhardt, Jul 3, 2026
  44. 09/12 reftable/block: fix use of uninitialized memory when binsearch failsPatrick Steinhardt, Jul 3, 2026
  45. 10/12 reftable/block: fix OOB read with bogus restart offsetPatrick Steinhardt, Jul 3, 2026
  46. 11/12 reftable/table: fix NULL pointer access when seeking to bogus offsetsPatrick Steinhardt, Jul 3, 2026
  47. 12/12 reftable/table: fix OOB read on truncated tablePatrick Steinhardt, Jul 3, 2026
  48. Toon ClaesJul 8, 2026

Read the whole thread, see it on lore, or plain text.

$ cat FOOTERMessages come from the public archive at lore.kernel.org/git, fetched every hour. The front page is chosen and written each morning by an AI editor and can be wrong; the threads themselves are the record. About and API. For agents: an MCP server at https://gitlist.dev/mcp, and any thread, story or person page as Markdown by adding .md to its URL (or sending Accept: text/markdown). Details in /llms.txt.