Enhance Mach-O layout checks

api/python/lief/MachO/__init__.pyi

@@ -1431,6 +1431,9 @@ class DyldInfo(LoadCommand):
 class DylibCommand(LoadCommand):
     name: str
 
+    @property
+    def name_offset(self) -> int: ...
+
     timestamp: int
 
     current_version: list[int]
@@ -1797,6 +1800,12 @@ class Header(lief.Object):
     @property
     def flags_list(self) -> list[Header.FLAGS]: ...
 
+    @property
+    def is_32bit(self) -> bool: ...
+
+    @property
+    def is_64bit(self) -> bool: ...
+
     def add(self, flag: Header.FLAGS) -> None: ...
 
     def remove(self, flag: Header.FLAGS) -> None: ...
@@ -2062,6 +2071,9 @@ class RPathCommand(LoadCommand):
     @staticmethod
     def create(path: str) -> Optional[RPathCommand]: ...
 
+    @property
+    def path_offset(self) -> int: ...
+
     path: str
 
     def __str__(self) -> str: ...

api/python/lief/__init__.py

@@ -7,7 +7,7 @@
     from ._lief import __version__, __tag__, __commit__, __is_tagged__, __extended__
 
     if __extended__:
-        from ._lief import __LIEF_MAIN_COMMIT__, __LIEF_EXTENDED_VERSION_STR__, __extended_version__
+        from ._lief_extended import __LIEF_MAIN_COMMIT__, __LIEF_EXTENDED_VERSION_STR__, __extended_version__
 
     # cf. https://github.com/pytorch/pytorch/blob/60a3b7425dde97fe8b46183c154a9c3b24f0c733/torch/__init__.py#L467-L470
     for attr in dir(_lief):

api/python/src/MachO/objects/pyDylibCommand.cpp

@@ -34,6 +34,9 @@ void create<DylibCommand>(nb::module_& m) {
         "Library's name"_doc,
         nb::rv_policy::reference_internal)
 
+    .def_prop_ro("name_offset", &DylibCommand::name_offset,
+                 "Original string offset of the name")
+
     .def_prop_rw("timestamp",
         nb::overload_cast<>(&DylibCommand::timestamp, nb::const_),
         nb::overload_cast<uint32_t>(&DylibCommand::timestamp),

api/python/src/MachO/objects/pyHeader.cpp

@@ -155,6 +155,12 @@ void create<Header>(nb::module_& m) {
         &Header::flags_list,
         "" RST_CLASS_REF(lief.MachO.Header.FLAGS) " as a list"_doc)
 
+    .def_prop_ro("is_32bit", &Header::is_32bit,
+                 R"doc(True is the binary is 32-bits)doc"_doc)
+
+    .def_prop_ro("is_64bit", &Header::is_64bit,
+                 R"doc(True is the binary is 64-bits)doc"_doc)
+
     .def("add",
         nb::overload_cast<Header::FLAGS>(&Header::add),
         "Add the given " RST_CLASS_REF(lief.MachO.Header.FLAGS) ""_doc,

api/python/src/MachO/objects/pyRPathCommand.cpp

@@ -34,6 +34,9 @@ void create<RPathCommand>(nb::module_& m) {
       "path"_a
     )
 
+    .def_prop_ro("path_offset", &RPathCommand::path_offset,
+                 "Original string offset of the path")
+
     .def_prop_rw("path",
         nb::overload_cast<>(&RPathCommand::path, nb::const_),
         nb::overload_cast<std::string>(&RPathCommand::path),

api/rust/cargo/lief/src/macho/commands/dylib.rs

@@ -17,6 +17,11 @@ impl Dylib<'_> {
         self.ptr.name().to_string()
     }
 
+    /// Original string offset of the name
+    pub fn name_offset(&self) -> u32 {
+        self.ptr.name_offset()
+    }
+
     /// Date and Time when the shared library was built
     pub fn timestamp(&self) -> u32 {
         self.ptr.timestamp()

api/rust/cargo/lief/src/macho/commands/rpath.rs

@@ -17,6 +17,11 @@ impl RPath<'_> {
     pub fn path(&self) -> String {
         self.ptr.path().to_string()
     }
+
+    /// Original string offset of the path
+    pub fn path_offset(&self) -> u32 {
+        self.ptr.path_offset()
+    }
 }
 
 impl std::fmt::Debug for RPath<'_> {

api/rust/cargo/lief/src/macho/header.rs

@@ -228,6 +228,16 @@ impl Header<'_> {
     pub fn reserved(&self) -> u32 {
         self.ptr.reserved()
     }
+
+    /// True if the binary is 32-bit
+    pub fn is_32bit(&self) -> bool {
+        self.ptr.is_32bit()
+    }
+
+    /// True if the binary is 64-bit
+    pub fn is_64bit(&self) -> bool {
+        self.ptr.is_64bit()
+    }
 }
 
 impl fmt::Debug for Header<'_> {

api/rust/cargo/lief/tests/macho_tests.rs

@@ -40,6 +40,7 @@ fn explore_macho(_: &str, macho: &lief::macho::Binary) {
     format!("{macho:?}");
     format!("{}", macho.entrypoint());
     format!("{:?}", macho.header());
+    format!("{}{}", macho.header().is_32bit(), macho.header().is_64bit());
     println!("{:?}:{}:{}", macho.platform(), macho.is_ios(), macho.is_macos());
     for section in macho.sections() {
         format!("{section:?}");

api/rust/include/LIEF/rust/MachO/Dylib.hpp

@@ -25,6 +25,8 @@ class MachO_Dylib : public MachO_Command {
   std::string name() const { return impl().name(); }
   uint32_t timestamp() const { return impl().timestamp(); }
 
+  auto name_offset() const { return impl().name_offset(); }
+
   auto current_version() const {
     return details::make_vector(impl().current_version());
   }

api/rust/include/LIEF/rust/MachO/Header.hpp

@@ -31,4 +31,7 @@ class MachO_Header : private Mirror<LIEF::MachO::Header> {
   auto sizeof_cmds() const { return get().sizeof_cmds(); }
   auto flags() const { return get().flags(); }
   auto reserved() const { return get().reserved(); }
+
+  bool is_32bit() const { return get().is_32bit(); }
+  bool is_64bit() const { return get().is_64bit(); }
 };

api/rust/include/LIEF/rust/MachO/RPathCommand.hpp

@@ -24,6 +24,8 @@ class MachO_RPathCommand : public MachO_Command {
   MachO_RPathCommand(const lief_t& base) : MachO_Command(base) {}
   std::string path() const { return impl().path(); };
 
+  auto path_offset() const { return impl().path_offset(); }
+
   static bool classof(const MachO_Command& cmd) {
     return lief_t::classof(&cmd.get());
   }

include/LIEF/MachO/DyldChainedFixups.hpp

@@ -79,6 +79,10 @@ class LIEF_API DyldChainedFixups : public LoadCommand {
 
     LIEF_API friend std::ostream& operator<<(std::ostream& os, const chained_starts_in_segment& info);
 
+    static chained_starts_in_segment create_empty_chained(SegmentCommand& segment) {
+      return chained_starts_in_segment(0, segment);
+    }
+
     private:
     friend class BinaryParser;
     friend class DyldChainedFixupsCreator;
@@ -192,6 +196,10 @@ class LIEF_API DyldChainedFixups : public LoadCommand {
   DYLD_CHAINED_FORMAT imports_format() const { return imports_format_; }
   void imports_format(DYLD_CHAINED_FORMAT fmt) { imports_format_ = fmt; }
 
+  chained_starts_in_segment& add(chained_starts_in_segment start_info) {
+    chained_starts_in_segment_.push_back(std::move(start_info));
+    return chained_starts_in_segment_.back();
+  }
 
   void accept(Visitor& visitor) const override;
 

include/LIEF/MachO/DylibCommand.hpp

@@ -104,6 +104,11 @@ class LIEF_API DylibCommand : public LoadCommand {
     return name_;
   }
 
+  /// Original string offset of the name
+  uint32_t name_offset() const {
+    return name_offset_;
+  }
+
   /// Date and Time when the shared library was built
   uint32_t timestamp() const {
     return timestamp_;
@@ -153,6 +158,7 @@ class LIEF_API DylibCommand : public LoadCommand {
     uint32_t current_version, uint32_t compat_version);
 
   std::string name_;
+  uint32_t name_offset_ = 0;
   uint32_t timestamp_ = 0;
   uint32_t current_version_ = 0;
   uint32_t compatibility_version_ = 0;

include/LIEF/MachO/Header.hpp

@@ -193,6 +193,18 @@ class LIEF_API Header : public Object {
     flags_ = flags;
   }
 
+  /// True if the binary is 32-bit
+  bool is_32bit() const {
+    return magic_ == MACHO_TYPES::MH_MAGIC ||
+           magic_ == MACHO_TYPES::MH_CIGAM;
+  }
+
+  /// True if the binary is 64-bit
+  bool is_64bit() const {
+    return magic_ == MACHO_TYPES::MH_MAGIC_64 ||
+           magic_ == MACHO_TYPES::MH_CIGAM_64;
+  }
+
   void remove(FLAGS flag);
 
   void reserved(uint32_t reserved) {

include/LIEF/MachO/RPathCommand.hpp

@@ -58,6 +58,11 @@ class LIEF_API RPathCommand : public LoadCommand {
     return path_;
   }
 
+  /// Original string offset of the path
+  uint32_t path_offset() const {
+    return path_offset_;
+  }
+
   void path(std::string path) {
     path_ = std::move(path);
   }
@@ -71,6 +76,7 @@ class LIEF_API RPathCommand : public LoadCommand {
   }
 
   private:
+  uint32_t path_offset_ = 0;
   std::string path_;
 };
 

include/LIEF/MachO/Section.hpp

@@ -161,7 +161,7 @@ class LIEF_API Section : public LIEF::Section {
   }
 
   /// Type of the section. This value can help to determine
-  /// the purpose of the section (e.g. MACHO_SECTION_TYPES::MACHO_SECTION_TYPES)
+  /// the purpose of the section (e.g. TYPE::INTERPOSING)
   TYPE type() const {
     return TYPE(flags_ & TYPE_MASK);
   }

src/MachO/Binary.cpp

@@ -1554,6 +1554,12 @@ LoadCommand* Binary::add(const SegmentCommand& segment) {
     current_offset += section.size();
   }
 
+  if (DyldChainedFixups* fixup = dyld_chained_fixups()) {
+    DyldChainedFixups::chained_starts_in_segment new_info =
+      DyldChainedFixups::chained_starts_in_segment::create_empty_chained(*segment_added);
+    fixup->add(std::move(new_info));
+  }
+
   refresh_seg_offset();
   return segment_added;
 }

src/MachO/CMakeLists.txt

@@ -67,6 +67,7 @@ target_sources(LIB_LIEF PRIVATE
   exports_trie.cpp
   hash.cpp
   json_api.cpp
+  layout_check.cpp
   utils.cpp
 )
 

src/MachO/DylibCommand.cpp

@@ -25,6 +25,7 @@ namespace MachO {
 
 DylibCommand::DylibCommand(const details::dylib_command& cmd) :
   LoadCommand::LoadCommand{static_cast<LoadCommand::TYPE>(cmd.cmd), cmd.cmdsize},
+  name_offset_{cmd.name},
   timestamp_{cmd.timestamp},
   current_version_{cmd.current_version},
   compatibility_version_{cmd.compatibility_version}

src/MachO/RPathCommand.cpp

@@ -31,7 +31,8 @@ RPathCommand::RPathCommand(std::string path) :
 }
 
 RPathCommand::RPathCommand(const details::rpath_command& rpath) :
-  LoadCommand::LoadCommand{LoadCommand::TYPE(rpath.cmd), rpath.cmdsize}
+  LoadCommand::LoadCommand{LoadCommand::TYPE(rpath.cmd), rpath.cmdsize},
+  path_offset_(rpath.path)
 {}
 
 void RPathCommand::accept(Visitor& visitor) const {