Apply relocations manually in DWARF parsing.

Hopefully addresses #7480.

Author: fuzyll

plugins/dwarf/shared/Cargo.toml

@@ -11,3 +11,4 @@ binaryninjacore-sys.workspace = true
 gimli = "0.31"
 zstd = "0.13.2"
 thiserror = "2.0"
+object = "0.36"

plugins/dwarf/shared/src/lib.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use gimli::{EndianRcSlice, Endianity, RunTimeEndian, SectionId};
+use object::{Object, ObjectSection, ObjectSymbol};
 
 use binaryninja::{
     binary_view::{BinaryView, BinaryViewBase, BinaryViewExt},
@@ -135,7 +136,7 @@ pub fn create_section_reader<'a, Endian: 'a + Endianity>(
                     };
                     // If the section has the compressed bit set
                     if (section_flags & 2048) != 0 {
-                        // Get section, trim header, decompress, return
+                        // Get section, trim header, decompress, and apply relocations before returning
                         let compressed_header_size = view.address_size() * 3;
 
                         let offset = section.start() + compressed_header_size as u64;
@@ -145,23 +146,18 @@ pub fn create_section_reader<'a, Endian: 'a + Endianity>(
                         let ch_type = endian.read_u32(&ch_type_vec);
 
                         if let Ok(buffer) = view.read_buffer(offset, len) {
-                            match ch_type {
-                                1 => {
-                                    return Ok(EndianRcSlice::new(
-                                        buffer.zlib_decompress().get_data().into(),
-                                        endian,
-                                    ));
-                                }
-                                2 => {
-                                    return Ok(EndianRcSlice::new(
-                                        zstd::decode_all(buffer.get_data())?.as_slice().into(),
-                                        endian,
-                                    ));
-                                }
-                                x => {
-                                    return Err(Error::UnknownCompressionMethod(x));
-                                }
-                            }
+                            let mut decompressed = match ch_type {
+                                1 => buffer.zlib_decompress().get_data().to_vec(),
+                                2 => zstd::decode_all(buffer.get_data())?,
+                                x => return Err(Error::UnknownCompressionMethod(x)),
+                            };
+
+                            apply_relocations(view, &section, &mut decompressed);
+
+                            return Ok(EndianRcSlice::new(
+                                Rc::from(decompressed.into_boxed_slice()),
+                                endian,
+                            ));
                         }
                     }
                 }
@@ -172,22 +168,233 @@ pub fn create_section_reader<'a, Endian: 'a + Endianity>(
         if len == 0 {
             Ok(EndianRcSlice::new(Rc::from([]), endian))
         } else {
-            Ok(EndianRcSlice::new(
-                Rc::from(view.read_vec(offset, len).as_slice()),
-                endian,
-            ))
+            let mut data = view.read_vec(offset, len);
+            apply_relocations(view, &section, &mut data);
+            Ok(EndianRcSlice::new(Rc::from(data.into_boxed_slice()), endian))
         }
     }
     // Truncate Mach-O section names to 16 bytes
     else if let Some(section) = view.section_by_name(&format!(
         "__{}",
         &section_name[1..section_name.len().min(15)]
     )) {
-        Ok(EndianRcSlice::new(
-            Rc::from(view.read_vec(section.start(), section.len()).as_slice()),
-            endian,
-        ))
+        let mut data = view.read_vec(section.start(), section.len());
+        apply_relocations(view, &section, &mut data);
+        Ok(EndianRcSlice::new(Rc::from(data.into_boxed_slice()), endian))
     } else {
         Ok(EndianRcSlice::new(Rc::from([]), endian))
     }
 }
+
+fn apply_relocations(
+    view: &BinaryView,
+    section: &binaryninja::section::Section,
+    data: &mut [u8],
+) {
+    if data.is_empty() {
+        return;
+    }
+
+    let section_start = section.start();
+    let section_end = section.end();
+    let relocation_ranges = view.relocation_ranges();
+    let is_little_endian = matches!(view.default_endianness(), Endianness::LittleEndian);
+    let section_name = section.name().to_string_lossy().into_owned();
+    let mut applied = false;
+
+    for range in relocation_ranges {
+        if range.end <= section_start || range.start >= section_end {
+            continue;
+        }
+
+        let relocations = view.relocations_at(range.start);
+        for relocation in relocations.iter() {
+            let info = relocation.info();
+
+            if !info.data_relocation {
+                continue;
+            }
+
+            let reloc_addr = info.address;
+            if reloc_addr < section_start {
+                continue;
+            }
+            let offset = (reloc_addr - section_start) as usize;
+            if offset >= data.len() {
+                continue;
+            }
+            if info.size == 0 || offset + info.size > data.len() {
+                log::warn!(
+                    "Skipping relocation at {:#x} (size {}) for section {}",
+                    reloc_addr,
+                    info.size,
+                    section_name
+                );
+                continue;
+            }
+
+            let existing = read_int(&data[offset..offset + info.size], is_little_endian);
+            let mut value = info.target.wrapping_add(info.addend as u64);
+
+            if info.implicit_addend {
+                value = value.wrapping_add(existing);
+            }
+
+            if info.base_relative {
+                value = value.wrapping_sub(info.base);
+            }
+
+            if info.pc_relative {
+                value = value.wrapping_sub(reloc_addr.wrapping_add(info.size as u64));
+            }
+
+            if info.size > 8 {
+                log::warn!(
+                    "Skipping relocation at {:#x} with unsupported size {}",
+                    reloc_addr,
+                    info.size
+                );
+                continue;
+            }
+
+            write_int(&mut data[offset..offset + info.size], value, is_little_endian);
+            applied = true;
+        }
+    }
+
+    if !applied {
+        let _ = apply_relocations_with_object(view, &section_name, data, is_little_endian);
+    }
+}
+
+fn read_int(bytes: &[u8], is_little_endian: bool) -> u64 {
+    let mut value = 0u64;
+    if is_little_endian {
+        for (i, byte) in bytes.iter().enumerate() {
+            value |= (*byte as u64) << (i * 8);
+        }
+    } else {
+        for (i, byte) in bytes.iter().enumerate() {
+            value |= (*byte as u64) << (8 * (bytes.len() - 1 - i));
+        }
+    }
+    value
+}
+
+fn write_int(bytes: &mut [u8], value: u64, is_little_endian: bool) {
+    if is_little_endian {
+        for (i, byte) in bytes.iter_mut().enumerate() {
+            *byte = (value >> (i * 8)) as u8;
+        }
+    } else {
+        let len = bytes.len();
+        for (i, byte) in bytes.iter_mut().enumerate() {
+            let shift = 8 * (len - 1 - i);
+            *byte = (value >> shift) as u8;
+        }
+    }
+}
+
+fn apply_relocations_with_object(
+    view: &BinaryView,
+    section_name: &str,
+    data: &mut [u8],
+    is_little_endian: bool,
+) -> bool {
+    let Some(file_bytes) = read_entire_view(view) else {
+        return false;
+    };
+
+    let Ok(file) = object::File::parse(&*file_bytes) else {
+        return false;
+    };
+
+    let Some(obj_section) = file.section_by_name(section_name) else {
+        return false;
+    };
+
+    let mut applied = false;
+
+    for (offset, relocation) in obj_section.relocations() {
+        let size_bits = relocation.size();
+        if size_bits == 0 {
+            continue;
+        }
+        let size = (size_bits / 8) as usize;
+        if size == 0 || size > 8 {
+            continue;
+        }
+
+        let offset = offset as usize;
+        if offset + size > data.len() {
+            continue;
+        }
+
+        let mut base = 0i128;
+        let mut target_section_name: Option<&str> = None;
+
+        match relocation.target() {
+            object::RelocationTarget::Symbol(symbol_index) => {
+                let Ok(symbol) = file.symbol_by_index(symbol_index) else {
+                    continue;
+                };
+                if let Some(section_index) = symbol.section_index() {
+                    let Ok(target_section) = file.section_by_index(section_index) else {
+                        continue;
+                    };
+                    if let Ok(name) = target_section.name() {
+                        target_section_name = Some(name);
+                    }
+                    base += target_section.address() as i128;
+                }
+                base += symbol.address() as i128;
+            }
+            object::RelocationTarget::Section(section_index) => {
+                let Ok(target_section) = file.section_by_index(section_index) else {
+                    continue;
+                };
+                if let Ok(name) = target_section.name() {
+                    target_section_name = Some(name);
+                }
+                base += target_section.address() as i128;
+            }
+            _ => {}
+        }
+
+        if let Some(name) = target_section_name {
+            if !is_debug_related_section(name) {
+                continue;
+            }
+        } else {
+            continue;
+        }
+
+        if relocation.kind() != object::RelocationKind::Absolute {
+            continue;
+        }
+
+        let _existing = read_int(&data[offset..offset + size], is_little_endian) as i128;
+        let addend = relocation.addend() as i128;
+        let value = base.wrapping_add(addend) as u64;
+        write_int(&mut data[offset..offset + size], value, is_little_endian);
+        applied = true;
+    }
+
+    applied
+}
+
+fn read_entire_view(view: &BinaryView) -> Option<Vec<u8>> {
+    let len = view.len();
+    if len == 0 || len > usize::MAX as u64 {
+        return None;
+    }
+    let data = view.read_vec(0, len as usize);
+    if data.len() as u64 != len {
+        return None;
+    }
+    Some(data)
+}
+
+fn is_debug_related_section(name: &str) -> bool {
+    name.starts_with(".debug") || name.starts_with(".zdebug")
+}