Add the endianness in the abstraction layer (resolve #29)

api/python/Abstract/objects/pyHeader.cpp

@@ -31,12 +31,12 @@ void init_LIEF_Header_class(py::module& m) {
     .def_property("architecture",
         static_cast<getter_t<LIEF::ARCHITECTURES>>(&LIEF::Header::architecture),
         static_cast<setter_t<LIEF::ARCHITECTURES>>(&LIEF::Header::architecture),
-        "Target architecture")
+        "Target architecture (" RST_CLASS_REF(lief.ARCHITECTURES) ")")
 
     .def_property("modes",
         static_cast<getter_t<const std::set<LIEF::MODES>&>>(&LIEF::Header::modes),
         static_cast<setter_t<const std::set<LIEF::MODES>&>>(&LIEF::Header::modes),
-        "Target modes (32-bits, 64-bits...)")
+        "Target " RST_CLASS_REF(lief.MODES) " (32-bits, 64-bits...)")
 
     .def_property("entrypoint",
         static_cast<getter_t<uint64_t>>(&LIEF::Header::entrypoint),
@@ -49,6 +49,11 @@ void init_LIEF_Header_class(py::module& m) {
         "Type of the binary (executable, library...)\n"
         "See: " RST_CLASS_REF(lief.OBJECT_TYPES) "")
 
+    .def_property("endianness",
+        static_cast<getter_t<LIEF::ENDIANNESS>>(&LIEF::Header::endianness),
+        static_cast<setter_t<LIEF::ENDIANNESS>>(&LIEF::Header::endianness),
+        "Binary endianness\n"
+        "See: " RST_CLASS_REF(lief.ENDIANNESS) "")
 
     .def_property_readonly("is_32",
         &LIEF::Header::is_32,

api/python/Abstract/pyEnums.cpp

@@ -25,4 +25,49 @@ void init_LIEF_Enum(py::module& m) {
     .value(PY_ENUM(LIEF::FILE_FORMATS::FORMAT_PE))
     .value(PY_ENUM(LIEF::FILE_FORMATS::FORMAT_MACHO))
     .export_values();
+
+  py::enum_<LIEF::OBJECT_TYPES>(m, "OBJECT_TYPES")
+    .value(PY_ENUM(LIEF::OBJECT_TYPES::TYPE_NONE))
+    .value(PY_ENUM(LIEF::OBJECT_TYPES::TYPE_EXECUTABLE))
+    .value(PY_ENUM(LIEF::OBJECT_TYPES::TYPE_LIBRARY))
+    .value(PY_ENUM(LIEF::OBJECT_TYPES::TYPE_OBJECT))
+    .export_values();
+
+  py::enum_<LIEF::ARCHITECTURES>(m, "ARCHITECTURES")
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_NONE))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_ARM))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_ARM64))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_MIPS))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_X86))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_PPC))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_SPARC))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_SYSZ))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_XCORE))
+    .value(PY_ENUM(LIEF::ARCHITECTURES::ARCH_INTEL))
+    .export_values();
+
+  py::enum_<LIEF::MODES>(m, "MODES")
+    .value(PY_ENUM(LIEF::MODES::MODE_NONE))
+    .value(PY_ENUM(LIEF::MODES::MODE_16))
+    .value(PY_ENUM(LIEF::MODES::MODE_32))
+    .value(PY_ENUM(LIEF::MODES::MODE_64))
+    .value(PY_ENUM(LIEF::MODES::MODE_ARM))
+    .value(PY_ENUM(LIEF::MODES::MODE_THUMB))
+    .value(PY_ENUM(LIEF::MODES::MODE_MCLASS))
+    .value(PY_ENUM(LIEF::MODES::MODE_MICRO))
+    .value(PY_ENUM(LIEF::MODES::MODE_MIPS3))
+    .value(PY_ENUM(LIEF::MODES::MODE_MIPS32R6))
+    .value(PY_ENUM(LIEF::MODES::MODE_MIPSGP64))
+    .value(PY_ENUM(LIEF::MODES::MODE_V7))
+    .value(PY_ENUM(LIEF::MODES::MODE_V8))
+    .value(PY_ENUM(LIEF::MODES::MODE_V9))
+    .value(PY_ENUM(LIEF::MODES::MODE_MIPS32))
+    .value(PY_ENUM(LIEF::MODES::MODE_MIPS64))
+    .export_values();
+
+  py::enum_<LIEF::ENDIANNESS>(m, "ENDIANNESS")
+    .value(PY_ENUM(LIEF::ENDIANNESS::ENDIAN_NONE))
+    .value(PY_ENUM(LIEF::ENDIANNESS::ENDIAN_BIG))
+    .value(PY_ENUM(LIEF::ENDIANNESS::ENDIAN_LITTLE))
+    .export_values();
 }

api/python/MachO/objects/pyHeader.cpp

@@ -33,8 +33,8 @@ void init_MachO_Header_class(py::module& m) {
     .def(py::init<>())
 
     .def_property("magic",
-        static_cast<getter_t<uint32_t>>(&Header::magic),
-        static_cast<setter_t<uint32_t>>(&Header::magic),
+        static_cast<getter_t<MACHO_TYPES>>(&Header::magic),
+        static_cast<setter_t<MACHO_TYPES>>(&Header::magic),
         ""
         )
 

api/python/MachO/pyMachOStructures.cpp

@@ -34,6 +34,16 @@ void init_MachO_Structures_enum(py::module& m) {
     .value(PY_ENUM(LIEF::MachO::CPU_TYPES::CPU_TYPE_POWERPC64))
     .export_values();
 
+  py::enum_<LIEF::MachO::MACHO_TYPES>(m, "MACHO_TYPES")
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::MH_MAGIC))
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::MH_CIGAM))
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::MH_MAGIC_64))
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::MH_CIGAM_64))
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::FAT_MAGIC))
+    .value(PY_ENUM(LIEF::MachO::MACHO_TYPES::FAT_CIGAM))
+    .export_values();
+
+
   py::enum_<LIEF::MachO::FILE_TYPES>(m, "FILE_TYPES")
     .value(PY_ENUM(LIEF::MachO::FILE_TYPES::MH_OBJECT))
     .value(PY_ENUM(LIEF::MachO::FILE_TYPES::MH_EXECUTE))

doc/sphinx/api/cpp/abstract.rst

@@ -47,16 +47,17 @@ Enums
 .. doxygenenum:: LIEF::FILE_FORMATS
    :project: lief
 
-
 .. doxygenenum:: LIEF::OBJECT_TYPES
    :project: lief
 
-
 .. doxygenenum:: LIEF::ARCHITECTURES
    :project: lief
 
-
 .. doxygenenum:: LIEF::MODES
    :project: lief
 
+.. doxygenenum:: LIEF::ENDIANNESS
+   :project: lief
+
+
 

doc/sphinx/api/python/abstract.rst

@@ -19,6 +19,17 @@ Binary
 
 ----------
 
+Header
+******
+
+.. autoclass:: lief.Header
+  :members:
+  :inherited-members:
+  :undoc-members:
+
+----------
+
+
 Section
 *******
 
@@ -38,3 +49,57 @@ Symbol
   :undoc-members:
 
 
+Enums
+*****
+
+
+File Formats
+~~~~~~~~~~~~
+
+.. autoclass:: lief.FILE_FORMATS
+  :members:
+  :inherited-members:
+  :undoc-members:
+
+----------
+
+
+Object types
+~~~~~~~~~~~~
+
+.. autoclass:: lief.OBJECT_TYPES
+  :members:
+  :inherited-members:
+  :undoc-members:
+
+----------
+
+
+Architectures
+~~~~~~~~~~~~~
+
+.. autoclass:: lief.ARCHITECTURES
+  :members:
+  :inherited-members:
+  :undoc-members:
+
+----------
+
+Modes
+~~~~~
+
+.. autoclass:: lief.MODES
+  :members:
+  :inherited-members:
+  :undoc-members:
+
+----------
+
+Endianness
+~~~~~~~~~~
+
+.. autoclass:: lief.ENDIANNESS
+  :members:
+  :inherited-members:
+  :undoc-members:
+

examples/python/abstract_reader.py

@@ -69,13 +69,10 @@ def print_imported_libraries(libraries):
 def read_binary(path):
     print("== Abstract Reader ==")
 
-    binary   = lief.parse(path)
-    binary   = super(binary.__class__, binary)
-    try:
-        header        = binary.header
-        print(header)
-    except lief.not_implemented as e:
-        print(e)
+    binary = lief.parse(path)
+    binary = super(binary.__class__, binary)
+    header = binary.header
+    print(header)
 
     sections      = binary.sections
     symbols       = binary.symbols

examples/python/macho_reader.py

@@ -41,7 +41,7 @@ def print_header(binary):
         flag = str(flag).split(".")[-1]
         flags += (flag if len(flags) == 0 else " - " + flag)
 
-    print(format_hex.format("Magic:",              header.magic))
+    print(format_str.format("Magic:",              str(header.magic).split(".")[-1]))
     print(format_str.format("CPU Type:",           str(header.cpu_type).split(".")[-1]))
     print(format_hex.format("CPU sub-type:",       header.cpu_subtype))
     print(format_str.format("File Type:",          str(header.file_type).split(".")[-1]))

include/LIEF/Abstract/EnumToString.hpp

@@ -24,6 +24,7 @@ DLL_PUBLIC const char* to_string(FILE_FORMATS e);
 DLL_PUBLIC const char* to_string(ARCHITECTURES e);
 DLL_PUBLIC const char* to_string(OBJECT_TYPES e);
 DLL_PUBLIC const char* to_string(MODES e);
+DLL_PUBLIC const char* to_string(ENDIANNESS e);
 } // namespace LIEF
 
 #endif

include/LIEF/Abstract/Header.hpp

@@ -38,6 +38,8 @@ class DLL_PUBLIC Header : public Visitable {
   const std::set<MODES>& modes(void)        const;
   OBJECT_TYPES           object_type(void)  const;
   uint64_t               entrypoint(void)   const;
+  ENDIANNESS             endianness(void)   const;
+
 
   //! @brief ``true`` if the binary target a ``32-bits`` architecture
   bool is_32(void) const;
@@ -52,6 +54,7 @@ class DLL_PUBLIC Header : public Visitable {
   void modes(const std::set<MODES>& m);
   void object_type(OBJECT_TYPES type);
   void entrypoint(uint64_t entrypoint);
+  void endianness(ENDIANNESS endianness);
 
   DLL_PUBLIC friend std::ostream& operator<<(std::ostream& os, const Header& hdr);
 
@@ -60,6 +63,7 @@ class DLL_PUBLIC Header : public Visitable {
   std::set<MODES> modes_;
   OBJECT_TYPES    object_type_;
   uint64_t        entrypoint_;
+  ENDIANNESS      endianness_;
 
 
 };

include/LIEF/Abstract/enums.hpp

@@ -49,25 +49,30 @@ enum ARCHITECTURES {
 
 enum MODES {
   MODE_NONE          = 0,
-  MODE_LITTLE_ENDIAN = 1,
-  MODE_BIG_ENDIAN    = 2,
-  MODE_16            = 3,
-  MODE_32            = 4,
-  MODE_64            = 5,
-  MODE_ARM           = 6,
-  MODE_THUMB         = 7,
-  MODE_MCLASS        = 8,
-  MODE_MICRO         = 9,
-  MODE_MIPS3         = 10,
-  MODE_MIPS32R6      = 11,
-  MODE_MIPSGP64      = 12,
-  MODE_V7            = 13,
-  MODE_V8            = 14,
-  MODE_V9            = 15,
-  MODE_MIPS32        = 16,
-  MODE_MIPS64        = 17,
+  MODE_16            = 1,
+  MODE_32            = 2,
+  MODE_64            = 3,
+  MODE_ARM           = 4,
+  MODE_THUMB         = 5,
+  MODE_MCLASS        = 6,
+  MODE_MICRO         = 7,
+  MODE_MIPS3         = 8,
+  MODE_MIPS32R6      = 9,
+  MODE_MIPSGP64      = 10,
+  MODE_V7            = 11,
+  MODE_V8            = 12,
+  MODE_V9            = 13,
+  MODE_MIPS32        = 14,
+  MODE_MIPS64        = 15,
 };
 
+enum ENDIANNESS {
+  ENDIAN_NONE   = 0,
+  ENDIAN_BIG    = 1,
+  ENDIAN_LITTLE = 2,
+};
+
+
 
 } // namespace LIEF
 #endif

include/LIEF/ELF/Header.hpp

@@ -35,7 +35,7 @@ class DLL_PUBLIC Header : public Visitable {
     using identity_t = std::array<uint8_t, IDENTITY::EI_NIDENT>;
 
     Header(void);
-    Header(const std::vector<uint8_t>&   header);
+    Header(const std::vector<uint8_t>& header);
     Header(const Elf32_Ehdr *header);
     Header(const Elf64_Ehdr *header);
 
@@ -56,6 +56,9 @@ class DLL_PUBLIC Header : public Visitable {
     //! @brief LIEF abstract architecture
     std::pair<ARCHITECTURES, std::set<MODES>> abstract_architecture(void) const;
 
+    //! @brief LIEF abstract endianness
+    ENDIANNESS abstract_endianness(void) const;
+
     //! @brief Version of the object file format
     VERSION   object_file_version(void) const;
     uint64_t  entrypoint(void) const;

include/LIEF/MachO/Header.hpp

@@ -39,7 +39,7 @@ class DLL_PUBLIC Header : public Visitable {
 
     virtual ~Header(void);
 
-    uint32_t               magic(void) const;
+    MACHO_TYPES            magic(void) const;
     CPU_TYPES              cpu_type(void) const;
     uint32_t               cpu_subtype(void) const;
     FILE_TYPES             file_type(void) const;
@@ -55,7 +55,10 @@ class DLL_PUBLIC Header : public Visitable {
 
     std::pair<ARCHITECTURES, std::set<MODES>> abstract_architecture(void) const;
 
-    void magic(uint32_t magic);
+    //! @brief LIEF abstract endiannes
+    ENDIANNESS abstract_endianness(void) const;
+
+    void magic(MACHO_TYPES magic);
     void cpu_type(CPU_TYPES cputype);
     void cpu_subtype(uint32_t cpusubtype);
     void file_type(FILE_TYPES filetype);
@@ -73,14 +76,14 @@ class DLL_PUBLIC Header : public Visitable {
     DLL_PUBLIC friend std::ostream& operator<<(std::ostream& os, const Header& hdr);
 
   private:
-    uint32_t   magic_;
-    CPU_TYPES  cputype_;
-    uint32_t   cpusubtype_;
-    FILE_TYPES filetype_;
-    uint32_t   ncmds_;
-    uint32_t   sizeofcmds_;
-    uint32_t   flags_;
-    uint32_t   reserved_;
+    MACHO_TYPES magic_;
+    CPU_TYPES   cputype_;
+    uint32_t    cpusubtype_;
+    FILE_TYPES  filetype_;
+    uint32_t    ncmds_;
+    uint32_t    sizeofcmds_;
+    uint32_t    flags_;
+    uint32_t    reserved_;
 };
 
 }

include/LIEF/PE/enums.inc

@@ -17,6 +17,9 @@ enum MACHINE_TYPES {
   IMAGE_FILE_MACHINE_POWERPC   = 0x1F0,  /**< Power PC little endian         */
   IMAGE_FILE_MACHINE_POWERPCFP = 0x1F1,  /**< Power PC with floating point   */
   IMAGE_FILE_MACHINE_R4000     = 0x166,  /**< MIPS with little endian        */
+  IMAGE_FILE_MACHINE_RISCV32   = 0x5032, /**< RISC-V 32-bit address space    */
+  IMAGE_FILE_MACHINE_RISCV64   = 0x5064, /**< RISC-V 64-bit address space    */
+  IMAGE_FILE_MACHINE_RISCV128  = 0x166,  /**< RISC-V 128-bit address space   */
   IMAGE_FILE_MACHINE_SH3       = 0x1A2,  /**< Hitachi SH3                    */
   IMAGE_FILE_MACHINE_SH3DSP    = 0x1A3,  /**< Hitachi SH3 DSP                */
   IMAGE_FILE_MACHINE_SH4       = 0x1A6,  /**< Hitachi SH4                    */

include/LIEF/PE/undef.h

@@ -33,6 +33,9 @@
 #undef IMAGE_FILE_MACHINE_POWERPC
 #undef IMAGE_FILE_MACHINE_POWERPCFP
 #undef IMAGE_FILE_MACHINE_R4000
+#undef IMAGE_FILE_MACHINE_RISCV32
+#undef IMAGE_FILE_MACHINE_RISCV64
+#undef IMAGE_FILE_MACHINE_RISCV128
 #undef IMAGE_FILE_MACHINE_SH3
 #undef IMAGE_FILE_MACHINE_SH3DSP
 #undef IMAGE_FILE_MACHINE_SH4