From 5fa3f3baa9b2e6e3a217469b53a93108cd7f1d42 Mon Sep 17 00:00:00 2001 From: Fish Wang Date: Wed, 11 Nov 2026 23:59:36 +0000 Subject: [PATCH] ELFCore: Walk core notes without pyelftools' note decoding pyelftools 5466000 ("Notes fixes", unreleased) names note types only for the owners whose namespace it knows, so FreeBSD notes now arrive with numeric types and the "NT_PRSTATUS" comparison never matches; every FreeBSD core loaded without threads. It also decodes each descriptor from its own bytes alone, and its x32 NT_PRPSINFO struct, with 32-bit uid and gid, is four bytes longer than the note, so loading an x32 core raised ELFParseError. Iterate PT_NOTE segments in ELFCore, keep note types as numbers, and parse NT_PRPSINFO and NT_FILE from the raw descriptor. pr_fname is read from the end of NT_PRPSINFO, which is where it sits on every ABI, which also fixes x32 cores reporting pr_fname "t" under every released pyelftools. --- cle/backends/elf/elfcore.py | 102 ++++++++++++++++++++++++++---------- tests/test_elfcore.py | 2 + 2 files changed, 76 insertions(+), 28 deletions(-) diff --git a/cle/backends/elf/elfcore.py b/cle/backends/elf/elfcore.py index c3b6b226f..f98b7e17e 100644 --- a/cle/backends/elf/elfcore.py +++ b/cle/backends/elf/elfcore.py @@ -31,6 +31,11 @@ # NetBSD names its process-wide note "NetBSD-CORE" and its per-LWP notes "NetBSD-CORE@". NETBSD_NAMESPACE_PREFIX = "NetBSD-CORE" +# Note types in the CORE namespace. FreeBSD numbers its own NT_PRSTATUS the same way. +NT_PRSTATUS = 1 +NT_PRPSINFO = 3 +NT_AUXV = 6 +NT_FILE = 0x46494C45 # The type of the Linux note holding a thread's GDT entries, in the LINUX namespace. NT_386_TLS = 512 @@ -137,9 +142,30 @@ def thread_registers(self, thread=None): thread = 0 return self._threads[thread]["registers"] - @staticmethod - def __note_desc(note): - return note.n_desc.encode("latin-1") if isinstance(note.n_desc, str) else note.n_desc + @property + def __endness(self): + return ">" if self.arch.memory_endness == "Iend_BE" else "<" + + def __iter_notes(self, segment): + """ + Yield the name, type and descriptor of every note in a PT_NOTE segment. pyelftools is not used + here: which note types it names, and which descriptors it decodes and how, changes between its + versions, while elfcore needs each type as the number its owner gave it and each descriptor raw. + """ + data = segment.data() + # n_namesz, n_descsz and n_type are four bytes wide in both ELF classes + nhdr = struct.Struct(self.__endness + "3I") + offset = 0 + while offset + nhdr.size <= len(data): + namesz, descsz, n_type = nhdr.unpack_from(data, offset) + name_start = offset + nhdr.size + desc_start = name_start + (namesz + 3) // 4 * 4 + offset = desc_start + (descsz + 3) // 4 * 4 + if desc_start + descsz > len(data): + log.warning("Ignoring a note that runs past the end of its PT_NOTE segment") + return + name = data[name_start : name_start + namesz].split(b"\x00", 1)[0].decode("latin-1") if namesz else None + yield name, n_type, data[desc_start : desc_start + descsz] def __extract_note_info(self): """ @@ -147,35 +173,35 @@ def __extract_note_info(self): """ for seg_readelf in self._reader.iter_segments(): if seg_readelf.header.p_type == "PT_NOTE": - for note in seg_readelf.iter_notes(): - if note.n_name == CORE_NAMESPACE: - if note.n_type == "NT_PRSTATUS": + for n_name, n_type, desc in self.__iter_notes(seg_readelf): + if n_name == CORE_NAMESPACE: + if n_type == NT_PRSTATUS: self.__cycle_thread() - self.__parse_prstatus(self.__note_desc(note)) - elif note.n_type == "NT_PRPSINFO": - self.__parse_prpsinfo(note.n_desc) - elif note.n_type == "NT_AUXV": - self.__parse_auxv(self.__note_desc(note)) - elif note.n_type == "NT_FILE": - self.__parse_files(note.n_desc) - elif note.n_name == LINUX_NAMESPACE: - if note.n_type == NT_386_TLS and self.arch.name == "X86": - self.__parse_x86_tls(self.__note_desc(note)) - elif note.n_name == FREEBSD_NAMESPACE: - if note.n_type == "NT_PRSTATUS": + self.__parse_prstatus(desc) + elif n_type == NT_PRPSINFO: + self.__parse_prpsinfo(desc) + elif n_type == NT_AUXV: + self.__parse_auxv(desc) + elif n_type == NT_FILE: + self.__parse_files(desc) + elif n_name == LINUX_NAMESPACE: + if n_type == NT_386_TLS and self.arch.name == "X86": + self.__parse_x86_tls(desc) + elif n_name == FREEBSD_NAMESPACE: + if n_type == NT_PRSTATUS: self.__cycle_thread() - self.__parse_freebsd_prstatus(self.__note_desc(note)) - elif note.n_name is not None and note.n_name.startswith(NETBSD_NAMESPACE_PREFIX): + self.__parse_freebsd_prstatus(desc) + elif n_name is not None and n_name.startswith(NETBSD_NAMESPACE_PREFIX): # NetBSD's NT_PRSTATUS is a struct netbsd_elfcore_procinfo, which holds no registers # at all - those live in one PT_GETREGS note per LWP. netbsd = netbsd_register_sets.get(self.arch.name) if netbsd is None: raise CLECompatibilityError(f"Architecture '{self.arch.name}' unsupported by ELFCore") - if note.n_type == netbsd.note_type: + if n_type == netbsd.note_type: self.__cycle_thread() - self.__parse_netbsd_regs(self.__note_desc(note), netbsd.gregset) - elif note.n_type == "NT_PRSTATUS": - log.warning("Don't know how to read the registers of a core note namespaced '%s'", note.n_name) + self.__parse_netbsd_regs(desc, netbsd.gregset) + elif n_type == NT_PRSTATUS: + log.warning("Don't know how to read the registers of a core note namespaced '%s'", n_name) self._replace_main_object_path() @@ -384,17 +410,37 @@ def __parse_netbsd_regs(self, desc, gregset): self.__current_thread.update({"registers": registers}) def __parse_prpsinfo(self, desc): - pr_fname = desc.pr_fname.split(b"\x00", 1)[0] + # Every ABI's struct elf_prpsinfo ends in pr_fname[16] and pr_psargs[80], with no padding after + # them; the widths of the fields before them, uid and gid among them, vary between ABIs. + if len(desc) < 96: + log.warning("Ignoring an NT_PRPSINFO of %d bytes, too short to hold pr_fname and pr_psargs", len(desc)) + return + pr_fname = desc[-96:-80].split(b"\x00", 1)[0] try: self.pr_fname = pr_fname.decode() except UnicodeDecodeError: self.pr_fname = repr(pr_fname) def __parse_files(self, desc): - self._page_size = desc.page_size + # A count and the page size, then a start, end and page offset per mapping, all words of the + # container's width, and finally the NUL-terminated name of each mapping's file. + word = self._reader.elfclass // 8 + fmt = "Q" if word == 8 else "I" + if len(desc) < 2 * word: + log.warning("Ignoring an NT_FILE of %d bytes", len(desc)) + return + count, page_size = struct.unpack_from(self.__endness + fmt * 2, desc) + names_start = (2 + 3 * count) * word + names = desc[names_start:].split(b"\x00") + if len(desc) < names_start or len(names) < count: + log.warning("Ignoring an NT_FILE of %d bytes that describes %d mappings", len(desc), count) + return + mappings = struct.iter_unpack(self.__endness + fmt * 3, desc[2 * word : names_start]) + + self._page_size = page_size self.filename_lookup = [ - (ent.vm_start, ent.vm_end, ent.page_offset * desc.page_size, self._remote_file_mapper(fn.decode())) - for ent, fn in zip(desc.Elf_Nt_File_Entry, desc.filename) + (start, end, page_offset * page_size, self._remote_file_mapper(fn.decode())) + for (start, end, page_offset), fn in zip(mappings, names[:count], strict=True) ] def __parse_x86_tls(self, desc): diff --git a/tests/test_elfcore.py b/tests/test_elfcore.py index cad1a0c3d..52bc11024 100644 --- a/tests/test_elfcore.py +++ b/tests/test_elfcore.py @@ -189,6 +189,8 @@ def test_prstatus_abi_mismatch(): assert core.threads == [] assert core.thread_registers() == {} assert ld.memory.load(0x400400, 8).hex() == "4883ec084883c408" + # x32's NT_PRPSINFO has the 16-bit uid and gid of i386, which shift every field after them + assert core.pr_fname == "a.out" # the auxv note is an ELFCLASS32 one whatever e_machine says, so its entries are two four-byte # words; read at eight the note runs out mid-entry and AT_HWCAP's CPUID word becomes nonsense