elf: implement GNU_PROPERTY_1_NEEDED support

Author: lief-agent

api/python/lief/ELF.pyi

@@ -5159,7 +5159,7 @@ class Needed(NoteGnuProperty.Property):
 
         def __int__(self) -> int: ...
 
-        UNKNOWN = 0
+        NEED = 0
 
         INDIRECT_EXTERN_ACCESS = 1
 

api/python/src/ELF/objects/NoteDetails/properties/CMakeLists.txt

@@ -2,6 +2,7 @@ target_sources(pyLIEF PRIVATE
   pyAArch64Feature.cpp
   pyAArch64PAuth.cpp
   pyGeneric.cpp
+  pyNeeded.cpp
   pyNoteNoCopyOnProtected.cpp
   pyX86Features.cpp
   pyX86ISA.cpp

api/python/src/ELF/objects/NoteDetails/properties/pyNeeded.cpp

@@ -0,0 +1,51 @@
+/* Copyright 2017 - 2026 R. Thomas
+ * Copyright 2017 - 2026 Quarkslab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string>
+
+#include <nanobind/stl/vector.h>
+
+#include "enums_wrapper.hpp"
+#include "ELF/pyELF.hpp"
+
+#include "LIEF/ELF/NoteDetails/properties/Needed.hpp"
+
+namespace LIEF::ELF::py {
+
+template<>
+void create<Needed>(nb::module_& m) {
+  using NEED = Needed::NEED;
+  nb::class_<Needed, NoteGnuProperty::Property>
+    Class(m, "Needed",
+      R"doc(
+      This class represents the ``GNU_PROPERTY_1_NEEDED`` note property
+      which provides information about additional features the object file
+      needs at runtime.
+      )doc"_doc);
+
+  enum_<NEED>(Class, "NEED")
+    .value("NEED", NEED::UNKNOWN, "")
+    .value("INDIRECT_EXTERN_ACCESS", NEED::INDIRECT_EXTERN_ACCESS,
+           "The object needs indirect external access")
+  ;
+
+  Class
+    .def_prop_ro("needs", &Needed::needs,
+        R"doc(
+        Return the list of the needed features.
+        )doc"_doc);
+}
+
+}

api/python/src/ELF/objects/NoteDetails/pyNoteGnuProperty.cpp

@@ -30,6 +30,7 @@
 #include "LIEF/ELF/NoteDetails/properties/StackSize.hpp"
 #include "LIEF/ELF/NoteDetails/properties/NoteNoCopyOnProtected.hpp"
 #include "LIEF/ELF/NoteDetails/properties/Generic.hpp"
+#include "LIEF/ELF/NoteDetails/properties/Needed.hpp"
 
 namespace LIEF::ELF::py {
 
@@ -68,6 +69,7 @@ void create<NoteGnuProperty>(nb::module_& m) {
 
   create<AArch64Feature>(m);
   create<AArch64PAuth>(m);
+  create<Needed>(m);
   create<X86Features>(m);
   create<X86ISA>(m);
   create<StackSize>(m);

api/rust/cargo/lief/src/elf/note/properties.rs

@@ -576,12 +576,44 @@ impl std::fmt::Debug for NoCopyOnProtected<'_> {
     }
 }
 
-/// Needed property
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+/// Flags for the `GNU_PROPERTY_1_NEEDED` property
+pub enum NeedFlag {
+    UNKNOWN,
+    /// The object needs indirect external access
+    INDIRECT_EXTERN_ACCESS,
+}
+
+impl From<u64> for NeedFlag {
+    fn from(value: u64) -> Self {
+        match value {
+            0 => NeedFlag::UNKNOWN,
+            1 => NeedFlag::INDIRECT_EXTERN_ACCESS,
+            _ => NeedFlag::UNKNOWN,
+        }
+    }
+}
+
+/// Needed property (`GNU_PROPERTY_1_NEEDED`)
+///
+/// This property conveys information about additional features that the
+/// object file needs at runtime (e.g. indirect external access).
 pub struct Needed<'a> {
     ptr: cxx::UniquePtr<ffi::ELF_NoteGnuProperty_Needed>,
     _owner: PhantomData<&'a ffi::ELF_NoteGnuProperty>,
 }
 
+impl Needed<'_> {
+    /// Return the list of needed features
+    pub fn needs(&self) -> Vec<NeedFlag> {
+        Vec::from(self.ptr.needs().as_slice())
+            .into_iter()
+            .map(NeedFlag::from)
+            .collect()
+    }
+}
+
 impl NoteProperty for Needed<'_> {
     fn get_base(&self) -> &ffi::ELF_NoteGnuProperty_Property {
         self.ptr.as_ref().unwrap().as_ref()
@@ -601,6 +633,7 @@ impl std::fmt::Debug for Needed<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Needed")
             .field("type", &self.property_type())
+            .field("needs", &self.needs())
             .finish()
     }
 }

api/rust/include/LIEF/rust/ELF/NoteGnuProperty.hpp

@@ -102,6 +102,10 @@ class ELF_NoteGnuProperty_Needed : public ELF_NoteGnuProperty_Property {
         static_cast<const ELF_NoteGnuProperty_Property::lief_t&>(impl)
     ) {}
 
+  auto needs() const {
+    return to_vector(as<lief_t>(this).needs());
+  }
+
   static bool classof(const ELF_NoteGnuProperty_Property& prop) {
     return lief_t::classof(&prop.get());
   }

doc/sphinx/formats/elf/cpp.rst

@@ -258,6 +258,13 @@ AArch64 PAuth
 .. doxygenclass:: LIEF::ELF::AArch64PAuth
 
 
+----------
+
+Needed
+******
+
+.. doxygenclass:: LIEF::ELF::Needed
+
 ----------
 
 No Copy on Protected

doc/sphinx/formats/elf/python.rst

@@ -358,6 +358,17 @@ AArch64 PAuth
 
 
 
+Needed
+******
+
+.. lief-inheritance:: lief._lief.ELF.Needed
+  :top-classes: lief._lief.ELF.NoteGnuProperty.Property
+  :parts: 2
+
+.. autoclass:: lief.ELF.Needed
+
+----------
+
 No Copy on Protected
 ********************
 

include/LIEF/ELF/NoteDetails/properties/Needed.hpp

@@ -15,24 +15,52 @@
  */
 #ifndef LIEF_ELF_NOTE_DETAILS_PROPERTIES_NEEDED_H
 #define LIEF_ELF_NOTE_DETAILS_PROPERTIES_NEEDED_H
+#include <vector>
 
+#include "LIEF/visibility.h"
 #include "LIEF/ELF/NoteDetails/NoteGnuProperty.hpp"
 
 namespace LIEF {
+class BinaryStream;
+
 namespace ELF {
 
-class Needed : public NoteGnuProperty::Property {
+/// This class represents the ``GNU_PROPERTY_1_NEEDED`` note property.
+///
+/// This property provides information about additional features that the
+/// object file needs at runtime (e.g. indirect external access).
+class LIEF_API Needed : public NoteGnuProperty::Property {
   public:
   enum class NEED {
     UNKNOWN = 0,
-    INDIRECT_EXTERN_ACCESS,
+    INDIRECT_EXTERN_ACCESS, ///< The object needs indirect external access
   };
+
+  /// Return the list of needed features
+  const std::vector<NEED>& needs() const {
+    return needs_;
+  }
+
   static bool classof(const NoteGnuProperty::Property* prop) {
     return prop->type() == NoteGnuProperty::Property::TYPE::NEEDED;
   }
 
+  static std::unique_ptr<Needed> create(BinaryStream& stream);
+
+  void dump(std::ostream& os) const override;
+
   ~Needed() override = default;
+
+  protected:
+  Needed(std::vector<NEED> needs) :
+    NoteGnuProperty::Property(NoteGnuProperty::Property::TYPE::NEEDED),
+    needs_(std::move(needs)) {}
+
+  std::vector<NEED> needs_;
 };
+
+LIEF_API const char* to_string(Needed::NEED need);
+
 }
 }
 

src/ELF/NoteDetails/NoteGnuProperty.cpp

@@ -30,6 +30,7 @@
 #include "LIEF/ELF/NoteDetails/properties/StackSize.hpp"
 #include "LIEF/ELF/NoteDetails/properties/X86Feature.hpp"
 #include "LIEF/ELF/NoteDetails/properties/X86ISA.hpp"
+#include "LIEF/ELF/NoteDetails/properties/Needed.hpp"
 #include "LIEF/ELF/NoteDetails/properties/NoteNoCopyOnProtected.hpp"
 
 #include "LIEF/BinaryStream/SpanStream.hpp"
@@ -117,7 +118,7 @@ inline std::unique_ptr<NoteGnuProperty::Property>
           (GNU_PROPERTY_UINT32_OR_LO <= type && type <= GNU_PROPERTY_UINT32_OR_HI))
       {
         switch (type) {
-          // TODO(romain): We need to support GNU_PROPERTY_1_NEEDED
+          case GNU_PROPERTY_1_NEEDED: return Needed::create(content);
           default: return Generic::create(type);
         }
       }