From 7df481dd76c05c89782721e9df5468be829c356b Mon Sep 17 00:00:00 2001
From: Alan Modra <amodra@gmail.com>
Date: Sat, 22 Nov 2025 09:22:10 +1030
Subject: [PATCH] PR 33638, debug_rnglists output

The fuzzed testcase in this PR continuously outputs an error about
the debug_rnglists header.  Fixed by taking notice of the error and
stopping output.  The patch also limits the length in all cases, not
just when a relocation is present, and limits the offset entry count
read from the header.  I removed the warning and the test for relocs
because the code can't work reliably with unresolved relocs in the
length field.

	PR 33638
	* dwarf.c (display_debug_rnglists_list): Return bool.  Rename
	"inital_length" to plain "length".  Verify length is large
	enough to read header.  Limit length to rest of section.
	Similarly limit offset_entry_count.
	(display_debug_ranges): Check display_debug_rnglists_unit_header
	return status.  Stop output on error.

CVE: CVE-2025-69648
Upstream-Status: Backport [https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=598704a00cbac5e85c2bedd363357b5bf6fcee33]

(cherry picked from commit 598704a00cbac5e85c2bedd363357b5bf6fcee33)
Signed-off-by: Deepak Rathore <deeratho@cisco.com>
Signed-off-by: Adarsh Jagadish Kamini <adarsh.jagadish.kamini@est.tech>
---
 binutils/dwarf.c | 67 ++++++++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

diff --git a/binutils/dwarf.c b/binutils/dwarf.c
index f4bcb677761..b4fb56351ec 100644
--- a/binutils/dwarf.c
+++ b/binutils/dwarf.c
@@ -8282,7 +8282,7 @@ display_debug_rnglists_list (unsigned char * start,
   return start;
 }
 
-static int
+static bool
 display_debug_rnglists_unit_header (struct dwarf_section *  section,
 				    uint64_t *              unit_offset,
 				    unsigned char *         poffset_size)
@@ -8290,7 +8290,8 @@ display_debug_rnglists_unit_header (struct dwarf_section *  section,
   uint64_t        start_offset = *unit_offset;
   unsigned char * p = section->start + start_offset;
   unsigned char * finish = section->start + section->size;
-  uint64_t        initial_length;
+  unsigned char * hdr;
+  uint64_t        length;
   unsigned char   segment_selector_size;
   unsigned int    offset_entry_count;
   unsigned int    i;
@@ -8299,66 +8300,59 @@ display_debug_rnglists_unit_header (struct dwarf_section *  section,
   unsigned char   offset_size;
 
   /* Get and check the length of the block.  */
-  SAFE_BYTE_GET_AND_INC (initial_length, p, 4, finish);
+  SAFE_BYTE_GET_AND_INC (length, p, 4, finish);
 
-  if (initial_length == 0xffffffff)
+  if (length == 0xffffffff)
     {
       /* This section is 64-bit DWARF 3.  */
-      SAFE_BYTE_GET_AND_INC (initial_length, p, 8, finish);
+      SAFE_BYTE_GET_AND_INC (length, p, 8, finish);
       *poffset_size = offset_size = 8;
     }
   else
     *poffset_size = offset_size = 4;
 
-  if (initial_length > (size_t) (finish - p))
-    {
-      /* If the length field has a relocation against it, then we should
-	 not complain if it is inaccurate (and probably negative).
-	 It is copied from .debug_line handling code.  */
-      if (reloc_at (section, (p - section->start) - offset_size))
-	initial_length = finish - p;
-      else
-	{
-	  warn (_("The length field (%#" PRIx64
-		  ") in the debug_rnglists header is wrong"
-		  " - the section is too small\n"),
-		initial_length);
-	  return 0;
-	}
-    }
-
-  /* Report the next unit offset to the caller.  */
-  *unit_offset = (p - section->start) + initial_length;
+  if (length < 8)
+    return false;
 
   /* Get the other fields in the header.  */
+  hdr = p;
   SAFE_BYTE_GET_AND_INC (version, p, 2, finish);
   SAFE_BYTE_GET_AND_INC (address_size, p, 1, finish);
   SAFE_BYTE_GET_AND_INC (segment_selector_size, p, 1, finish);
   SAFE_BYTE_GET_AND_INC (offset_entry_count, p, 4, finish);
 
   printf (_(" Table at Offset: %#" PRIx64 ":\n"), start_offset);
-  printf (_("  Length:          %#" PRIx64 "\n"), initial_length);
+  printf (_("  Length:          %#" PRIx64 "\n"), length);
   printf (_("  DWARF version:   %u\n"), version);
   printf (_("  Address size:    %u\n"), address_size);
   printf (_("  Segment size:    %u\n"), segment_selector_size);
   printf (_("  Offset entries:  %u\n"), offset_entry_count);
 
+  if (length > (size_t) (finish - hdr))
+    length = finish - hdr;
+
+  /* Report the next unit offset to the caller.  */
+  *unit_offset = (hdr - section->start) + length;
+
   /* Check the fields.  */
   if (segment_selector_size != 0)
     {
       warn (_("The %s section contains "
 	      "unsupported segment selector size: %d.\n"),
 	    section->name, segment_selector_size);
-      return 0;
+      return false;
     }
 
   if (version < 5)
     {
       warn (_("Only DWARF version 5+ debug_rnglists info "
 	      "is currently supported.\n"));
-      return 0;
+      return false;
     }
 
+  uint64_t max_off_count = (length - 8) / offset_size;
+  if (offset_entry_count > max_off_count)
+    offset_entry_count = max_off_count;
   if (offset_entry_count != 0)
     {
       printf (_("\n   Offsets starting at %#tx:\n"), p - section->start);
@@ -8372,7 +8366,7 @@ display_debug_rnglists_unit_header (struct dwarf_section *  section,
 	}
     }
 
-  return 1;
+  return true;
 }
 
 static bool
@@ -8404,6 +8398,7 @@ display_debug_ranges (struct dwarf_section *section,
   uint64_t last_offset = 0;
   uint64_t next_rnglists_cu_offset = 0;
   unsigned char offset_size;
+  bool ok_header = true;
 
   if (bytes == 0)
     {
@@ -8493,8 +8488,12 @@ display_debug_ranges (struct dwarf_section *section,
       /* If we've moved on to the next compile unit in the rnglists section - dump the unit header(s).  */
       if (is_rnglists && next_rnglists_cu_offset < offset)
 	{
-	  while (next_rnglists_cu_offset < offset)
-	    display_debug_rnglists_unit_header (section, &next_rnglists_cu_offset, &offset_size);
+	  while (ok_header && next_rnglists_cu_offset < offset)
+	    ok_header = display_debug_rnglists_unit_header (section,
+							    &next_rnglists_cu_offset,
+							    &offset_size);
+	  if (!ok_header)
+	    break;
 	  printf (_("    Offset   Begin    End\n"));
 	}
 
@@ -8548,10 +8547,12 @@ display_debug_ranges (struct dwarf_section *section,
     }
 
   /* Display trailing empty (or unreferenced) compile units, if any.  */
-  if (is_rnglists)
+  if (is_rnglists && ok_header)
     while (next_rnglists_cu_offset < section->size)
-      display_debug_rnglists_unit_header (section, &next_rnglists_cu_offset, &offset_size);
-
+      if (!display_debug_rnglists_unit_header (section,
+					       &next_rnglists_cu_offset,
+					       &offset_size))
+	break;
   putchar ('\n');
 
   free (range_entries);
-- 
2.35.6

